How to use Optional.shouldNotBePresent method of io.kotest.matchers.optional.matchers class

Best Kotest code snippet using io.kotest.matchers.optional.matchers.Optional.shouldNotBePresent

AttachmentServiceTest.kt

Source:AttachmentServiceTest.kt

1package com.github.njuro.jard.attachment2import com.github.njuro.jard.TEST_ATTACHMENT_AVI3import com.github.njuro.jard.TEST_ATTACHMENT_DOCX4import com.github.njuro.jard.TEST_ATTACHMENT_PNG5import com.github.njuro.jard.TEST_FOLDER_NAME6import com.github.njuro.jard.TestDataRepository7import com.github.njuro.jard.WithContainerDatabase8import com.github.njuro.jard.attachment9import com.github.njuro.jard.attachment.storage.RemoteStorageService10import com.github.njuro.jard.attachmentPath11import com.github.njuro.jard.common.Constants.DEFAULT_THUMBNAIL_EXTENSION12import com.github.njuro.jard.common.Constants.THUMBNAIL_FOLDER_NAME13import com.github.njuro.jard.embedData14import com.github.njuro.jard.metadata15import com.github.njuro.jard.multipartFile16import com.ninjasquad.springmockk.MockkBean17import io.kotest.matchers.booleans.shouldBeTrue18import io.kotest.matchers.file.shouldBeAFile19import io.kotest.matchers.file.shouldBeReadable20import io.kotest.matchers.file.shouldExist21import io.kotest.matchers.file.shouldHaveExtension22import io.kotest.matchers.file.shouldHaveNameWithoutExtension23import io.kotest.matchers.file.shouldNotBeEmpty24import io.kotest.matchers.file.shouldNotExist25import io.kotest.matchers.nulls.shouldBeNull26import io.kotest.matchers.nulls.shouldNotBeNull27import io.kotest.matchers.optional.shouldNotBePresent28import io.kotest.matchers.should29import io.kotest.matchers.shouldBe30import io.kotest.matchers.string.shouldNotBeBlank31import io.mockk.Runs32import io.mockk.every33import io.mockk.just34import org.junit.jupiter.api.AfterEach35import org.junit.jupiter.api.BeforeEach36import org.junit.jupiter.api.DisplayName37import org.junit.jupiter.api.Nested38import org.junit.jupiter.api.Test39import org.springframework.beans.factory.annotation.Autowired40import org.springframework.boot.test.context.SpringBootTest41import org.springframework.transaction.annotation.Transactional42import java.io.File43@SpringBootTest44@WithContainerDatabase45@Transactional46internal class AttachmentServiceTest {47    @Autowired48    private lateinit var attachmentService: AttachmentService49    @MockkBean50    private lateinit var remoteStorageService: RemoteStorageService51    @Autowired52    private lateinit var db: TestDataRepository53    @BeforeEach54    @AfterEach55    fun `delete test folder`() {56        val testFolder = attachmentPath(TEST_FOLDER_NAME).toFile()57        if (testFolder.exists()) {58            testFolder.deleteRecursively().shouldBeTrue()59        }60    }61    @Nested62    @DisplayName("save attachment")63    inner class SaveAttachment {64        private fun getRemoteUrl(folder: String, filename: String) = "https://remote-storage.com/$folder-$filename"65        @BeforeEach66        fun setUpMocks() {67            every {68                remoteStorageService.uploadFile(69                    ofType(String::class),70                    ofType(String::class),71                    ofType(File::class)72                )73            } answers { getRemoteUrl(firstArg(), secondArg()) }74        }75        @Test76        fun `save image attachment with thumbnail`() {77            val file = multipartFile("attachment.png", TEST_ATTACHMENT_PNG)78            val attachment =79                attachment(80                    category = AttachmentCategory.IMAGE,81                    filename = file.name,82                    folder = TEST_FOLDER_NAME,83                    metadata = metadata(mimeType = "image/png")84                )85            attachmentService.saveAttachment(attachment, file).should {86                it.metadata.shouldNotBeNull()87                it.remoteStorageUrl shouldBe getRemoteUrl(attachment.folder, attachment.filename)88                it.file.shouldMatchFile("attachment", "png")89                it.remoteStorageThumbnailUrl shouldBe getRemoteUrl(90                    "$TEST_FOLDER_NAME/$THUMBNAIL_FOLDER_NAME",91                    attachment.filename92                )93                it.thumbnailFile.shouldMatchFile("attachment", "png")94            }95        }96        @Test97        fun `save non-image attachment with thumbnail`() {98            val file = multipartFile("attachment.avi", TEST_ATTACHMENT_AVI)99            val attachment =100                attachment(101                    category = AttachmentCategory.VIDEO,102                    filename = file.name,103                    folder = TEST_FOLDER_NAME,104                    metadata = metadata(mimeType = "video/avi")105                )106            attachmentService.saveAttachment(attachment, file).should {107                it.remoteStorageUrl.shouldNotBeBlank()108                it.file.shouldMatchFile("attachment", "avi")109                it.thumbnailFile.shouldMatchFile("attachment", DEFAULT_THUMBNAIL_EXTENSION)110                it.remoteStorageThumbnailUrl.shouldNotBeBlank()111            }112        }113        @Test114        fun `save non-image attachment without thumbnail`() {115            val file = multipartFile("attachment.docx", TEST_ATTACHMENT_DOCX)116            val attachment =117                attachment(118                    category = AttachmentCategory.TEXT,119                    filename = file.name,120                    folder = TEST_FOLDER_NAME,121                    metadata = metadata(mimeType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document")122                )123            attachmentService.saveAttachment(attachment, file).should {124                it.file.shouldMatchFile("attachment", "docx")125                it.remoteStorageUrl.shouldNotBeBlank()126                it.thumbnailFile.shouldBeNull()127                it.remoteStorageThumbnailUrl.shouldBeNull()128            }129        }130        @Test131        fun `save embedded attachment`() {132            val attachment =133                attachment(category = AttachmentCategory.EMBED, embedData = embedData(embedUrl = "some-url"))134            attachmentService.saveEmbeddedAttachment(attachment).shouldNotBeNull()135        }136    }137    @Test138    fun `delete attachment`() {139        every { remoteStorageService.uploadFile(any(), any(), any()) } returns null140        every { remoteStorageService.deleteFile(ofType(String::class), ofType(String::class)) } just Runs141        val file = multipartFile("attachment.png", TEST_ATTACHMENT_PNG)142        val attachment =143            attachment(144                category = AttachmentCategory.IMAGE,145                filename = file.name,146                folder = TEST_FOLDER_NAME,147                metadata = metadata(mimeType = "image/png")148            )149        val saved = attachmentService.saveAttachment(attachment, file)150        attachmentService.deleteAttachment(saved)151        db.select(saved).shouldNotBePresent()152        attachment.file.shouldNotExist()153        attachment.thumbnailFile.shouldNotExist()154    }155    private fun File.shouldMatchFile(name: String, extension: String) = should {156        it.shouldExist()157        it.shouldBeAFile()158        it.shouldHaveNameWithoutExtension(name)159        it.shouldHaveExtension(extension)160        it.shouldBeReadable()161        it.shouldNotBeEmpty()162    }163}...

PostFacadeTest.kt

Source:PostFacadeTest.kt

1package com.github.njuro.jard.post2import com.github.njuro.jard.MapperTest3import com.github.njuro.jard.TestDataRepository4import com.github.njuro.jard.WithContainerDatabase5import com.github.njuro.jard.board6import com.github.njuro.jard.board.Board7import com.github.njuro.jard.boardSettings8import com.github.njuro.jard.common.Constants9import com.github.njuro.jard.post10import com.github.njuro.jard.thread11import com.github.njuro.jard.thread.Thread12import com.github.njuro.jard.toForm13import com.github.njuro.jard.user14import com.github.njuro.jard.user.UserFacade15import com.github.njuro.jard.user.UserRole16import com.github.njuro.jard.utils.validation.PropertyValidationException17import com.ninjasquad.springmockk.MockkBean18import io.kotest.assertions.throwables.shouldThrow19import io.kotest.matchers.optional.shouldBePresent20import io.kotest.matchers.optional.shouldNotBePresent21import io.kotest.matchers.should22import io.kotest.matchers.shouldBe23import io.mockk.every24import io.mockk.spyk25import org.junit.jupiter.api.BeforeEach26import org.junit.jupiter.api.DisplayName27import org.junit.jupiter.api.Nested28import org.junit.jupiter.api.Test29import org.springframework.beans.factory.annotation.Autowired30import org.springframework.transaction.annotation.Transactional31import java.time.OffsetDateTime32@WithContainerDatabase33@Transactional34internal class PostFacadeTest : MapperTest() {35    @Autowired36    private lateinit var postFacade: PostFacade37    @MockkBean38    private lateinit var userFacade: UserFacade39    @Autowired40    private lateinit var db: TestDataRepository41    private lateinit var board: Board42    private lateinit var thread: Thread43    @BeforeEach44    fun setUp() {45        board = spyk(db.insert(board(label = "r")))46        thread = db.insert(thread(board).apply { originalPost.deletionCode = "12345" })47        every { userFacade.currentUser } returns user(role = UserRole.ADMIN).toDto()48    }49    @Nested50    @DisplayName("create post")51    inner class CreatePost {52        @Test53        fun `create post`() {54            val postForm = post(thread).toForm()55            postFacade.createPost(postForm, thread.toDto()).thread.id shouldBe thread.id56        }57        @Test58        fun `create post and set capcode`() {59            val postForm = post(thread).toForm().apply { isCapcode = true }60            postFacade.createPost(postForm, thread.toDto()).capcode shouldBe UserRole.ADMIN61        }62        @Test63        fun `create post and force default poster name`() {64            every { board.settings } returns boardSettings(65                forceDefaultPosterName = true,66                defaultPosterName = "Anonymous"67            )68            val postForm = post(thread).toForm().apply { name = "John" }69            postFacade.createPost(postForm, thread.toDto()).name shouldBe "Anonymous"70        }71        @Test72        fun `create post and set country data`() {73            every { board.settings } returns boardSettings(countryFlags = true)74            val postForm = post(thread).toForm().apply { ip = "185.63.157.241" }75            postFacade.createPost(postForm, thread.toDto()).should {76                it.countryCode shouldBe "sk"77                it.countryName shouldBe "Slovakia"78            }79        }80    }81    @Nested82    @DisplayName("delete own post")83    inner class DeleteOwnPost {84        @Test85        fun `delete post with valid deletion code`() {86            val reply = db.insert(post(thread, deletionCode = "abcde", postNumber = 2L))87            postFacade.deleteOwnPost(reply.toDto(), "abcde")88            db.select(reply).shouldNotBePresent()89        }90        @Test91        fun `don't delete post without deletion code`() {92            val reply = db.insert(post(thread, deletionCode = "", postNumber = 2L))93            shouldThrow<PropertyValidationException> {94                postFacade.deleteOwnPost(reply.toDto(), "")95            }96            db.select(reply).shouldBePresent()97        }98        @Test99        fun `don't delete post with invalid deletion code`() {100            val reply = db.insert(post(thread, deletionCode = "abcde", postNumber = 2L))101            shouldThrow<PropertyValidationException> {102                postFacade.deleteOwnPost(reply.toDto(), "xxxxx")103            }104            db.select(reply).shouldBePresent()105        }106        @Test107        fun `don't delete first post in thread`() {108            shouldThrow<PropertyValidationException> {109                postFacade.deleteOwnPost(thread.originalPost.toDto(), thread.originalPost.deletionCode)110            }111            db.select(thread.originalPost).shouldBePresent()112        }113        @Test114        fun `don't delete post after limit`() {115            val createdAt = OffsetDateTime.now().minusMinutes(Constants.OWN_POST_DELETION_TIME_LIMIT + 1L)116            val reply =117                db.insert(post(thread, deletionCode = "abcde", createdAt = createdAt, postNumber = 2L))118            shouldThrow<PropertyValidationException> {119                postFacade.deleteOwnPost(reply.toDto(), "abcde")120            }121            db.select(reply).shouldBePresent()122        }123    }124}...

PostServiceTest.kt

Source:PostServiceTest.kt

1package com.github.njuro.jard.post2import com.github.njuro.jard.TestDataRepository3import com.github.njuro.jard.WithContainerDatabase4import com.github.njuro.jard.board5import com.github.njuro.jard.board.Board6import com.github.njuro.jard.post7import com.github.njuro.jard.thread8import com.github.njuro.jard.thread.Thread9import io.kotest.assertions.throwables.shouldThrow10import io.kotest.matchers.collections.shouldContainExactly11import io.kotest.matchers.nulls.shouldNotBeNull12import io.kotest.matchers.optional.shouldBePresent13import io.kotest.matchers.optional.shouldNotBePresent14import io.kotest.matchers.should15import io.kotest.matchers.shouldBe16import io.kotest.matchers.string.shouldContain17import org.junit.jupiter.api.BeforeEach18import org.junit.jupiter.api.Test19import org.springframework.beans.factory.annotation.Autowired20import org.springframework.boot.test.context.SpringBootTest21import org.springframework.transaction.annotation.Transactional22@SpringBootTest23@WithContainerDatabase24@Transactional25internal class PostServiceTest {26    @Autowired27    private lateinit var postService: PostService28    @Autowired29    private lateinit var postRepository: PostRepository30    @Autowired31    private lateinit var db: TestDataRepository32    private lateinit var board: Board33    private lateinit var thread: Thread34    @BeforeEach35    fun setUp() {36        board = db.insert(board(label = "r"))37        thread = db.insert(thread(board))38    }39    @Test40    fun `create new post`() {41        val post = post(thread, postNumber = 0L, body = "Test post\n")42        postService.savePost(post).should {43            it.id.shouldNotBeNull()44            it.postNumber shouldBe 1L45            it.body.shouldContain("<br/>")46        }47    }48    @Test49    fun `resolve post`() {50        val post = db.insert(post(thread, postNumber = 2L))51        postService.resolvePost(board.label, post.postNumber).postNumber shouldBe post.postNumber52    }53    @Test54    fun `don't resolve non-existing post`() {55        shouldThrow<PostNotFoundException> {56            postService.resolvePost(board.label, 0L)57        }58    }59    @Test60    fun `get latest replies for thread`() {61        (2L..8L).forEach { db.insert(post(thread, postNumber = it)) }62        postService.getLatestRepliesForThread(thread.id, thread.originalPost.id).map(Post::getPostNumber)63            .shouldContainExactly(4L, 5L, 6L, 7L, 8L)64    }65    @Test66    fun `delete single post`() {67        val reply = db.insert(post(thread, postNumber = 2L))68        db.select(reply).shouldBePresent()69        postService.deletePost(reply)70        db.select(reply).shouldNotBePresent()71    }72    @Test73    fun `delete multiple posts`() {74        val replies = (2L..5L).map { db.insert(post(thread, postNumber = it)) }75        postRepository.countByThreadId(thread.id) shouldBe 5L76        postService.deletePosts(replies)77        postRepository.countByThreadId(thread.id) shouldBe 1L78    }79}...

BanRepositoryTest.kt

Source:BanRepositoryTest.kt

1@file:Suppress("UNUSED_VARIABLE")2package com.github.njuro.jard.ban3import com.github.njuro.jard.TestDataRepository4import com.github.njuro.jard.WithContainerDatabase5import com.github.njuro.jard.WithTestDataRepository6import com.github.njuro.jard.ban7import com.github.njuro.jard.user8import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder9import io.kotest.matchers.optional.shouldBePresent10import io.kotest.matchers.optional.shouldNotBePresent11import org.junit.jupiter.api.Test12import org.springframework.beans.factory.annotation.Autowired13import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest14import org.springframework.transaction.annotation.Transactional15import java.time.OffsetDateTime16@DataJpaTest17@WithTestDataRepository18@WithContainerDatabase19@Transactional20internal class BanRepositoryTest {21    @Autowired22    private lateinit var banRepository: BanRepository23    @Autowired24    private lateinit var db: TestDataRepository25    @Test26    fun `find by ip`() {27        val ban1 = banRepository.save(ban(ip = "127.0.0.1"))28        val ban2 = banRepository.save(ban(ip = "127.0.0.1"))29        banRepository.findByIp(ban1.ip).map(Ban::getId).shouldContainExactlyInAnyOrder(ban1.id, ban2.id)30    }31    @Test32    fun `find by status and expiration date before given date`() {33        val baseDate = OffsetDateTime.now()34        val ban1 = banRepository.save(ban(status = BanStatus.ACTIVE, validTo = baseDate.minusDays(1L)))35        val ban2 = banRepository.save(ban(status = BanStatus.ACTIVE, validTo = baseDate.plusDays(1L)))36        val ban3 = banRepository.save(ban(status = BanStatus.ACTIVE, validTo = baseDate.minusDays(2L)))37        val ban4 = banRepository.save(ban(status = BanStatus.UNBANNED, validTo = baseDate.minusDays(2L)))38        banRepository.findByStatusAndValidToBefore(BanStatus.ACTIVE, baseDate).map(Ban::getId)39            .shouldContainExactlyInAnyOrder(ban1.id, ban3.id)40    }41    @Test42    fun `find by ip and status`() {43        val ban = banRepository.save(ban(status = BanStatus.WARNING, ip = "127.0.0.1"))44        banRepository.findByIpAndStatus(ban.ip, ban.status).shouldBePresent()45        banRepository.findByIpAndStatus(ban.ip, BanStatus.UNBANNED).shouldNotBePresent()46    }47    @Test48    fun `find by banned by`() {49        val user1 = db.insert(user(username = "First", email = "first@mail.com"))50        val user2 = db.insert(user(username = "Second", email = "second@mail.com"))51        val ban1 = banRepository.save(ban(bannedBy = user1))52        val ban2 = banRepository.save(ban(bannedBy = user1))53        val ban3 = banRepository.save(ban(bannedBy = user2))54        banRepository.findByBannedBy(user1).map(Ban::getId).shouldContainExactlyInAnyOrder(ban1.id, ban2.id)55    }56}...

OptionalMatchersTest.kt

Source:OptionalMatchersTest.kt

1package com.sksamuel.kotest.matchers.optional2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.core.spec.style.ShouldSpec4import io.kotest.matchers.optional.beEmpty5import io.kotest.matchers.optional.bePresent6import io.kotest.matchers.optional.shouldBeEmpty7import io.kotest.matchers.optional.shouldBePresent8import io.kotest.matchers.optional.shouldNotBeEmpty9import io.kotest.matchers.optional.shouldNotBePresent10import io.kotest.matchers.should11import io.kotest.matchers.shouldBe12import io.kotest.matchers.shouldNot13import io.kotest.matchers.throwable.shouldHaveMessage14import java.util.Optional15class OptionalMatchersTest : ShouldSpec({16    context("Empty optional") {17        val optional = Optional.empty<Any>()18        should("Be empty") {19            optional.shouldBeEmpty()20            optional should beEmpty()21        }22        should("Not be present") {23            optional.shouldNotBePresent()24            optional shouldNot bePresent()25        }26        should("Fail to be notEmpty") {27            shouldThrow<AssertionError> { optional.shouldNotBeEmpty() }28            shouldThrow<AssertionError> { optional shouldNot beEmpty() }29        }30        should("Fail to be present") {31            shouldThrow<AssertionError> { optional.shouldBePresent() }32            shouldThrow<AssertionError> { optional should bePresent() }33        }34    }35    context("Present optional") {36        val optional = Optional.of("A")37        should("Be present") {38            optional.shouldBePresent()39            optional should bePresent()40        }41        42        should("Return the present value for usage in more assertions") {43            optional.shouldBePresent() shouldBe "A"44        } 45        should("Allow matchers with present value as a receiver") {46            optional shouldBePresent {47                this shouldBe "A"48            }49        }50        51        should("Allow matchers with present value as parameter") {52            optional shouldBePresent {53                it shouldBe "A"54            }55        }56        57        should("Execute code inside the receiver") {58            shouldThrow<RuntimeException> {59                optional shouldBePresent {60                    throw RuntimeException("Ensuring the block is actually executed")61                }62            } shouldHaveMessage "Ensuring the block is actually executed"63            64            shouldThrow<AssertionError> {65                optional shouldBePresent {66                    this shouldBe "B"67                }68            }69        }70    }71}) ...

matchers.kt

Source:matchers.kt

1package io.kotest.matchers.optional2import io.kotest.matchers.Matcher3import io.kotest.matchers.MatcherResult4import io.kotest.matchers.should5import io.kotest.matchers.shouldNot6import java.util.Optional7/**8 * Asserts that a [Optional] is empty9 *10 * ```11 * Optional.empty().shouldBeEmpty() // Assertion passes12 *13 * Optional.of("A").shouldBeEmpty() // Assertion fails14 * ```15 */16fun <T> Optional<T>.shouldBeEmpty() = this should beEmpty()17/**18 * Asserts that a [Optional] is not empty19 *20 * ```21 * Optional.of("A").shouldNotBeEmpty() // Assertion passes22 *23 * Optional.empty().shouldNotBeEmpty() // Assertion fails24 * ```25 */26fun <T> Optional<T>.shouldNotBeEmpty() = this shouldNot beEmpty()27/**28 * Matcher to verify whether an [Optional] is empty or not29 */30fun <T> beEmpty() = object : Matcher<Optional<T>> {31    override fun test(value: Optional<T>) = MatcherResult(32       !value.isPresent,33       { "Expected optional to be empty, but instead was ${value.get()}" },34       { "Expected optional to not be empty, but was" }35    )36}37/**38 * Verifies if this [Optional] is present then execute [block] with it's value39 *40 * ```41 * val optional = Optional.of("A")42 *43 * optional shouldBePresent {44 *     it shouldBe "A"45 * }46 *47 * ```48 */49infix fun <T> Optional<T>.shouldBePresent(block: T.(value: T) -> Unit): T {50    shouldBePresent()51    get().block(get())52    return get()53}54/**55 * Verifies if this [Optional] is present56 *57 * ```58 * val optional = Optional.of("A")59 *60 * optional.shouldBePresent()61 *62 * ```63 *64 * Further assertions can be made using the returned value65 *66 * ```67 * val optional = Optional.of("A")68 *69 * val present = optional.shouldBePresent()70 * present shouldBe "A"71 * ```72 *73 */74fun <T> Optional<T>.shouldBePresent(): T {75    this should bePresent()76    return get()77}78/**79 * Verifies t hat this Optional contains no value80 */81fun <T> Optional<T>.shouldNotBePresent() = this shouldNot bePresent()82/**83 * Matcher to verify whether a matcher contains a value or not84 */85fun <T> bePresent() = object : Matcher<Optional<T>> {86    override fun test(value: Optional<T>) = MatcherResult(87       value.isPresent,88       { "Expected optional to be present, but was empty instead" },89       { "Expected optional to not be present, but was ${value.get()}" }90    )91}...

KoinModuleFactoryTest.kt

Source:KoinModuleFactoryTest.kt

1package dev.madetobuild.typedconfig.koin2import dev.madetobuild.typedconfig.runtime.source.MapSource3import dev.madetobuild.typedconfig.test.KoinConfig4import io.kotest.matchers.optional.shouldBePresent5import io.kotest.matchers.optional.shouldNotBePresent6import io.kotest.matchers.shouldBe7import org.junit.jupiter.api.Test8import org.junit.jupiter.api.extension.RegisterExtension9import org.koin.core.qualifier.named10import org.koin.test.KoinTest11import org.koin.test.inject12import org.koin.test.junit5.KoinTestExtension13import java.util.*14class KoinModuleFactoryTest : KoinTest {15    private val key by inject<Int>(named("integer"))16    private val nestedKey by inject<String>(named("nested.foo"))17    private val optionalKey by inject<Optional<Int>>(named("optionalKey"))18    private val optionalKey2 by inject<Optional<Int>>(named("optionalKey2"))19    @JvmField20    @RegisterExtension21    val koinTestExtension = KoinTestExtension.create {22        val input = mapOf(23            "integer" to 42,24            "nested.foo" to "bar",25            "optionalKey" to 1,26            // "optionalKey2" intentionally omitted27        )28        modules(KoinConfig(MapSource(input)).asKoinModule())29    }30    @Test31    fun topLevelKey() {32        key shouldBe 4233    }34    @Test35    fun nestedKey() {36        nestedKey shouldBe "bar"37    }38    @Test39    fun optionalAndPresent() {40        optionalKey shouldBePresent {41            it shouldBe 142        }43    }44    @Test45    fun optionalButAbsent() {46        optionalKey2.shouldNotBePresent()47    }48}...

RootUserCreationTest.kt

Source:RootUserCreationTest.kt

1package com.github.njuro.jard.security2import com.github.njuro.jard.WithContainerDatabase3import com.github.njuro.jard.user.UserRepository4import io.kotest.matchers.optional.shouldBePresent5import io.kotest.matchers.optional.shouldNotBePresent6import org.junit.jupiter.api.Test7import org.springframework.beans.factory.annotation.Autowired8import org.springframework.boot.test.context.SpringBootTest9import org.springframework.test.context.TestPropertySource10@SpringBootTest11@TestPropertySource(properties = ["app.user.root.username=root", "app.user.root.password=root"])12internal sealed class RootUserCreationTest {13    @Autowired14    protected lateinit var userRepository: UserRepository15    @TestPropertySource(properties = ["app.user.root.enabled=true"])16    @WithContainerDatabase17    internal class RootUserAllowedTest : RootUserCreationTest() {18        @Test19        fun `root user created`() {20            userRepository.findByUsernameIgnoreCase("root").shouldBePresent()21        }22    }23    @TestPropertySource(properties = ["app.user.root.enabled=false"])24    @WithContainerDatabase25    internal class RootUserNotAllowedTest : RootUserCreationTest() {26        @Test27        fun `root user not created`() {28            userRepository.findByUsernameIgnoreCase("root").shouldNotBePresent()29        }30    }31}...

Optional.shouldNotBePresent

Using AI Code Generation

1import io.kotest.matchers.optional.shouldNotBePresent2import io.kotest.matchers.optional.shouldNotBeEmpty3import io.kotest.matchers.optional.shouldBePresent4import io.kotest.matchers.optional.shouldBeEmpty5import io.kotest.matchers.optional.shouldBePresentAnd6import io.kotest.matchers.optional.shouldBePresentAnd7import io.kotest.matchers.optional.shouldBePresentAnd8import io.kotest.matchers.optional.shouldBePresentAnd9import io.kotest.matchers.optional.shouldBePresentAnd10import io.kotest.matchers.optional.shouldBePresentAnd11import io.kotest.matchers.optional.shouldBePresentAnd12import io.kotest.matchers.optional.shouldBePresentAnd13import io.kotest.matchers.optional.shouldBePresentAnd14import io.kotest.matchers.optional.shouldBePresentAnd15import io.kotest.matchers.optional.shouldBePresentAnd

Optional.shouldNotBePresent

Using AI Code Generation

1import io.kotest.matchers.optional.shouldNotBePresent2import io.kotest.matchers.optional.shouldBePresent3import io.kotest.matchers.optional.shouldBePresent4import io.kotest.matchers.optional.shouldBePresent5import io.kotest.matchers.optional.shouldBePresent6import io.kotest.matchers.optional.shouldBePresent7import io.kotest.matchers.optional.shouldBePresent8import io.kotest.matchers.optional.shouldBePresent9import io.kotest.matchers.optional.shouldBePresent10import io.kotest.matchers.optional.shouldBePresent11import io.kotest.matchers.optional.shouldBePresent12import io.kotest.matchers.optional.shouldBePresent13import io.kotest.matchers.optional.shouldBePresent14import io.kotest.matchers.optional.shouldBePresent15import io.kotest.matchers.optional.shouldBePresent16import io

Optional.shouldNotBePresent

Using AI Code Generation

1val optional: Optional = Optional.empty()2val optional: Optional = Optional.of(“Kotest”)3val optional: Optional = Optional.of(“Kotest”)4val optional: Optional = Optional.of(“Kotest”)5val optional: Optional = Optional.of(“Kotest”)6val optional: Optional = Optional.of(“Kotest”)7val optional: Optional = Optional.of(“Kotest”)8val optional: Optional = Optional.of(“Kotest”)9val optional: Optional = Optional.of(“Kotest”)10val optional: Optional = Optional.of(“Kotest”)

Optional.shouldNotBePresent

Using AI Code Generation

1    shouldNotBePresent(Optional.empty())2    shouldNotBePresent(Optional.ofNullable(null))3    shouldBePresent(Optional.of("Hello"))4    shouldBePresent(Optional.ofNullable("Hello"))5    shouldBePresent(Optional.of("Hello"))6    shouldBePresent(Optional.ofNullable("Hello"))7    shouldBePresent(Optional.of("Hello"))8    shouldBePresent(Optional.ofNullable("Hello"))9    shouldBePresent(Optional.of("Hello"))10    shouldBePresent(Optional.ofNullable("Hello"))11    shouldBePresent(Optional.of("Hello"))12    shouldBePresent(Optional.ofNullable("Hello"))13    shouldBePresent(Optional.of("Hello"))14    shouldBePresent(Optional.ofNullable("Hello"))15    shouldBePresent(Optional.of("Hello"))16    shouldBePresent(Optional.ofNullable("Hello"))17    shouldBePresent(Optional.of("Hello"))18    shouldBePresent(Optional.ofNullable("Hello"))19    shouldBePresent(Optional.of("Hello"))20    shouldBePresent(Optional.ofNullable("Hello"))21    shouldBePresent(Optional.of("Hello"))22    shouldBePresent(Optional.ofNullable("Hello"))23    shouldBePresent(Optional.of("Hello"))24    shouldBePresent(Optional.ofNullable("Hello"))25    shouldBePresent(Optional.of("Hello"))26    shouldBePresent(Optional.ofNullable("Hello"))

Optional.shouldNotBePresent

Using AI Code Generation

1Optional . empty < Int >(). shouldNotBePresent ()2Optional . of ( 1 ). shouldBePresent ()3Optional . of ( 1 ). shouldBePresent ( 1 )4Optional . of ( 1 ). shouldBePresent { it > 0 }5Optional . empty < Int >(). shouldBeNull ()6Optional . of ( 1 ). shouldBePresent ()7Optional . of ( 1 ). shouldBePresent ( 1 )8Optional . of ( 1 ). shouldBePresent { it > 0 }9Optional . of ( 1 ). shouldBePresent ( 1 ) { it > 0 }10Optional . of ( 1 ). shouldBePresent ( 1 , 2 )11Optional . of ( 1 ). shouldBePresent ( 1 , 2 ) { it > 0 }12Optional . of ( 1 ). shouldBePresent ( 1 , 2 ) { it > 0 } { it < 2 }

Optional.shouldNotBePresent

Using AI Code Generation

1assertThat (optional). shouldNotBePresent ()2assertThat (optional). shouldBePresent ()3assertThat (optional). shouldBePresent (expectedValue)4assertThat (optional). shouldBePresent (expectedValue)5assertThat (optional). shouldBePresent (expectedValue)6assertThat (optional). shouldBePresent (expectedValue)7assertThat (optional). shouldBePresent (expectedValue)8assertThat (optional). shouldBePresent (expectedValue)9assertThat (optional). shouldBePresent (expectedValue)10assertThat (optional). shouldBePresent (expectedValue)

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.