Screenplay minimal prep

pom.xml

@@ -72,6 +72,12 @@
             <version>1.3</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.mockk</groupId>
+            <artifactId>mockk</artifactId>
+            <version>1.12.0</version>
+            <scope>test</scope>
+        </dependency>
 
         <dependency>
             <groupId>org.jetbrains.kotlin</groupId>
@@ -90,6 +96,11 @@
             <version>1.5.4</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.seleniumhq.selenium</groupId>
+            <artifactId>selenium-api</artifactId>
+            <version>3.141.59</version>
+        </dependency>
     </dependencies>
     <build>
         <testSourceDirectory>src/test/kotlin</testSourceDirectory>

src/main/kotlin/Ability.kt

@@ -0,0 +1,3 @@
+interface Ability {
+
+}

src/main/kotlin/Actor.kt

@@ -0,0 +1,17 @@
+import ability.BrowseTheWeb
+import org.openqa.selenium.WebDriver
+
+class Actor(val abilities: MutableList<Ability> = mutableListOf()) {
+
+
+  var webDriver: WebDriver? = null
+
+  fun perform(performable: Performable) = performable.performAs(this)
+
+  fun asks(question: Question): Any = question.answerAs(this)
+  fun can(ability: Ability) {
+    when (ability) {
+      is BrowseTheWeb -> webDriver = ability.webDriver
+    }
+  }
+}

src/main/kotlin/BrowserInteraction.kt

@@ -0,0 +1,10 @@
+import ability.BrowseTheWeb
+
+interface BrowserInteraction : Interaction<BrowseTheWeb> {
+
+  override fun performUsing(ability: BrowseTheWeb)
+
+  override fun performAs(actor: Actor) {
+    performUsing(BrowseTheWeb.with(actor.webDriver!!))
+  }
+}

src/main/kotlin/Interaction.kt

@@ -0,0 +1,6 @@
+interface Interaction<A : Ability> : Performable {
+
+
+  fun performUsing(ability: A)
+
+}

src/main/kotlin/Performable.kt

@@ -0,0 +1,5 @@
+interface Performable {
+
+  fun performAs(actor: Actor)
+
+}

src/main/kotlin/Question.kt

@@ -0,0 +1,9 @@
+fun interface Question {
+  fun answerAs(actor: Actor): Any {
+    val ability = actor.abilities[0]
+    return answerUsingAbility(ability)
+  }
+
+  fun answerUsingAbility(ability: Ability): Any
+
+}

src/main/kotlin/Task.kt

@@ -0,0 +1,3 @@
+interface Task : Performable {
+
+}

src/main/kotlin/ability/BrowseTheWeb.kt

@@ -0,0 +1,12 @@
+package ability
+
+import Ability
+import org.openqa.selenium.WebDriver
+
+class BrowseTheWeb(val webDriver: WebDriver) : Ability {
+
+
+  companion object {
+    fun with(webdriver: WebDriver): BrowseTheWeb = BrowseTheWeb(webdriver)
+  }
+}

src/test/kotlin/AbilityTest.kt

@@ -0,0 +1,72 @@
+import ability.BrowseTheWeb
+import io.mockk.confirmVerified
+import io.mockk.impl.annotations.RelaxedMockK
+import io.mockk.impl.annotations.SpyK
+import io.mockk.verify
+import org.junit.Assert.*
+import org.junit.Test
+import org.openqa.selenium.WebDriver
+
+class AbilityTest {
+
+
+  @RelaxedMockK
+  lateinit var mockAbility: Ability
+
+  @SpyK
+  var task = object : Task {
+    override fun performAs(actor: Actor) {}
+  }
+
+
+  @SpyK
+  var interaction = object : Interaction<Ability> {
+    override fun performUsing(ability: Ability) {}
+    override fun performAs(actor: Actor) {
+      performUsing(actor.abilities.first())
+    }
+  }
+
+  @Test
+  fun `ability enables interaction`() {
+    val actor = Actor(abilities = mutableListOf(mockAbility))
+    actor.perform(interaction)
+    verify(exactly = 1) { interaction.performUsing(mockAbility) }
+    verify(exactly = 1) { interaction.performAs(actor) }
+    confirmVerified(interaction)
+
+  }
+
+  @Test
+  fun `no ability to interact will throw`() {
+    val actor = Actor()
+    assertThrows(NoSuchElementException::class.java) {
+      actor.perform(interaction)
+    }
+  }
+
+  @Test
+  fun `tasks don't need abilities`() {
+    val actor = Actor()
+    actor.perform(task)
+    verify(exactly = 1) { task.performAs(actor) }
+    confirmVerified(interaction)
+  }
+
+  @RelaxedMockK
+  lateinit var browser: WebDriver
+
+  @Test
+  internal fun `ability to browse with a webdriver`() {
+    val actor = Actor()
+    actor.can(BrowseTheWeb.with(browser))
+    actor.perform(object : BrowserInteraction {
+      override fun performUsing(ability: BrowseTheWeb) {
+        ability.webDriver.navigate().to("page")
+      }
+    })
+    verify(exactly = 1) { browser.navigate().to("page") }
+    confirmVerified(browser)
+
+  }
+}

src/test/kotlin/ActorTest.kt

@@ -0,0 +1,48 @@
+import io.mockk.confirmVerified
+import io.mockk.impl.annotations.RelaxedMockK
+import io.mockk.verify
+import org.hamcrest.MatcherAssert
+import org.hamcrest.Matchers
+import org.junit.Test
+
+class ActorTest {
+
+  @RelaxedMockK
+  lateinit var mockQuestion: Question
+
+  @RelaxedMockK
+  lateinit var mockAbility: Ability
+
+  @RelaxedMockK
+  lateinit var mockTask: Task
+
+  @Test
+  fun `an actor exists`() {
+    val actor = Actor()
+    MatcherAssert.assertThat(actor, Matchers.`is`(Matchers.not(Matchers.nullValue())))
+  }
+
+  @Test
+  fun `actor has ability`() {
+    val actor = Actor(abilities = mutableListOf(mockAbility))
+    MatcherAssert.assertThat(actor.abilities[0], Matchers.`is`(Matchers.not(Matchers.nullValue())))
+  }
+
+  @Test
+  fun `actor performs tasks`() {
+    val actor = Actor()
+    actor.perform(mockTask)
+    verify(exactly = 1) { mockTask.performAs(actor) }
+    confirmVerified(mockTask)
+  }
+
+  @Test
+  fun `actor asks question`() {
+    val actor = Actor()
+    val answer = actor.asks(mockQuestion)
+
+    MatcherAssert.assertThat(answer, Matchers.not(Matchers.`is`(Matchers.nullValue())))
+    verify(exactly = 1) { mockQuestion.answerAs(actor) }
+    confirmVerified(mockQuestion)
+  }
+}

src/test/kotlin/TaskTest.kt

@@ -0,0 +1,43 @@
+import io.mockk.impl.annotations.RelaxedMockK
+import io.mockk.impl.annotations.SpyK
+import io.mockk.verify
+import org.junit.Test
+
+class TaskTest {
+
+
+  @RelaxedMockK
+  lateinit var mockAbility: Ability
+
+  @SpyK
+  var task = object : Task {
+    override fun performAs(actor: Actor) {
+      actor.perform(subTask)
+    }
+  }
+
+  @SpyK
+  var subTask = object : Task {
+    override fun performAs(actor: Actor) {
+      actor.perform(interaction)
+    }
+  }
+
+  @SpyK
+  var interaction = object : Interaction<Ability> {
+    override fun performUsing(ability: Ability) {}
+
+    override fun performAs(actor: Actor) {
+      performUsing(actor.abilities.first())
+    }
+
+  }
+
+  @Test
+  fun `task are performed recursively`() {
+    val actor = Actor(abilities = mutableListOf(mockAbility))
+    actor.perform(task)
+    verify(exactly = 1) { interaction.performUsing(mockAbility) }
+  }
+
+}