Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Varargs support in mockable #3292

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Apr 5, 2020
Merged

Varargs support in mockable #3292

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions build.sbt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -219,6 +219,7 @@ lazy val testTests = crossProject(JSPlatform, JVMPlatform)
.dependsOn(testRunner)
.settings(buildInfoSettings("zio.test"))
.settings(skip in publish := true)
.settings(macroExpansionSettings)
.enablePlugins(BuildInfoPlugin)

lazy val testTestsJVM = testTests.jvm.settings(dottySettings)
Expand Down
107 changes: 107 additions & 0 deletions test-tests/shared/src/main/scala/zio/test/mock/modules.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,107 @@
package zio.test.mock

import zio.{ Has, IO, Tagged, ZIO }

/**
* https://github.com/scalamacros/paradise/issues/75
*
* We can't define module in the same scope with macro application
* */
object modules {
type EmptyModule = Has[EmptyModule.Service]
object EmptyModule {
trait Service
}

type SinglePureValModule = Has[SinglePureValModule.Service]
object SinglePureValModule {
trait Service {
val foo: ZIO[Any, Nothing, Unit]
}
}

type SimplePureDefsModule = Has[SimplePureDefsModule.Service]
object SimplePureDefsModule {
trait Service {
val static: IO[String, String]
def zeroParams: IO[String, String]
def zeroParamsWithParens(): IO[String, String]
def singleParam(a: Int): IO[String, String]
def manyParams(a: Int, b: String, c: Long): IO[String, String]
def manyParamLists(a: Int)(b: String)(c: Long): IO[String, String]
}
}

type SimpleImpureDefsModule = Has[SimpleImpureDefsModule.Service]
object SimpleImpureDefsModule {
trait Service {
def zeroParams: String
def zeroParamsWithParens(): String
def singleParam(a: Int): String
def manyParams(a: Int, b: String, c: Long): String
def manyParamLists(a: Int)(b: String)(c: Long): String
}
}

type OverloadedPureDefsModule = Has[OverloadedPureDefsModule.Service]
object OverloadedPureDefsModule {
trait Service {
def overloaded(n: Int): IO[String, String]
def overloaded(n: Long): IO[String, String]
}
}

type OverloadedImpureDefsModule = Has[OverloadedImpureDefsModule.Service]
object OverloadedImpureDefsModule {
trait Service {
def overloaded(n: Int): String
def overloaded(n: Long): String
}
}

type PolyPureDefsModule = Has[PolyPureDefsModule.Service]
object PolyPureDefsModule {
trait Service {
def polyInput[I: Tagged](v: I): IO[String, String]
def polyError[E: Tagged](v: String): IO[E, String]
def polyOutput[A: Tagged](v: String): IO[String, A]
def polyInputError[I: Tagged, E: Tagged](v: I): IO[E, String]
def polyInputOutput[I: Tagged, A: Tagged](v: I): IO[String, A]
def polyErrorOutput[E: Tagged, A: Tagged](v: String): IO[E, A]
def polyInputErrorOutput[I: Tagged, E: Tagged, A: Tagged](v: I): IO[E, A]
def polyMixed[A: Tagged]: IO[String, (A, String)]
def polyBounded[A <: AnyVal: Tagged]: IO[String, A]
}
}

type PolyImpureDefsModule = Has[PolyImpureDefsModule.Service]
object PolyImpureDefsModule {
trait Service {
def polyInput[I: Tagged](v: I): String
def polyError[E <: Throwable: Tagged](v: String): String
def polyOutput[A: Tagged](v: String): A
def polyInputError[I: Tagged, E <: Throwable: Tagged](v: I): String
def polyInputOutput[I: Tagged, A: Tagged](v: I): A
def polyErrorOutput[E <: Throwable: Tagged, A: Tagged](v: String): A
def polyInputErrorOutput[I: Tagged, E <: Throwable: Tagged, A: Tagged](v: I): A
def polyMixed[A: Tagged]: (A, String)
def polyBounded[A <: AnyVal: Tagged]: A
}
}

type VarargsPureDefsModule = Has[VarargsPureDefsModule.Service]
object VarargsPureDefsModule {
trait Service {
def simpleVarargs(a: Int, b: String*): IO[String, Int]
def curriedVarargs(a: Int, b: String*)(c: Long, d: Double*): IO[String, Int]
}
}

type VarargsImpureDefsModule = Has[VarargsImpureDefsModule.Service]
object VarargsImpureDefsModule {
trait Service {
def simpleVarargs(a: Int, b: String*): String
def curriedVarargs(a: Int, b: String*)(c: Long, d: Double*): String
}
}
}
219 changes: 219 additions & 0 deletions test-tests/shared/src/test/scala-2.x/zio/test/mock/MockableSpec.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,219 @@
package zio.test.mock

import zio.test.Assertion._
import zio.test._
import zio.test.mock.modules._

/**
* https://github.com/scalamacros/paradise/issues/75
*
* We can't typecheck @mockable with typeCheck
* */
object MockableSpec extends DefaultRunnableSpec {

def spec = suite("MockableSpec")(
suite("Mockable macro")(
test("compiles when applied to object with empty Service") {
assert({
@mockable[EmptyModule.Service]
object ModuleMock

object Check {
val mock: Mock[EmptyModule] = ModuleMock
}

Check
})(anything)
},
testM("fails when applied to object without type arg") {
assertM(typeCheck {
"""
@mockable
object ModuleMock
"""
})(isLeft(anything))
},
testM("fails when applied to trait") {
assertM(typeCheck {
"""
object Module {
trait Service
}

@mockable[Module.Service]
trait ModuleMock
"""
})(isLeft(anything))
},
testM("fails when applied to class") {
assertM(typeCheck {
"""
object Module {
trait Service
}

@mockable[Module.Service]
class ModuleMock
"""
})(isLeft(anything))
},
test("generates mocks for pure value") {
assert({
@mockable[SinglePureValModule.Service]
object ModuleMock

object Check {
val mock: Mock[SinglePureValModule] = ModuleMock

val Foo: ModuleMock.Effect[Unit, Nothing, Unit] = ModuleMock.Foo
}

Check
})(anything)
},
test("generates mocks for simple pure methods") {
assert({
@mockable[SimplePureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[SimplePureDefsModule] = ModuleMock

val Static: ModuleMock.Effect[Unit, String, String] = ModuleMock.Static
val ZeroParams: ModuleMock.Effect[Unit, String, String] = ModuleMock.ZeroParams
val ZeroParamsWithParens: ModuleMock.Effect[Unit, String, String] = ModuleMock.ZeroParamsWithParens
val SingleParam: ModuleMock.Effect[Int, String, String] = ModuleMock.SingleParam
val ManyParams: ModuleMock.Effect[(Int, String, Long), String, String] = ModuleMock.ManyParams
val ManyParamLists: ModuleMock.Effect[(Int, String, Long), String, String] = ModuleMock.ManyParamLists
}

Check
})(anything)
},
test("generates mocks for simple impure methods") {
assert({
@mockable[SimpleImpureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[SimpleImpureDefsModule] = ModuleMock

val ZeroParams: ModuleMock.Method[Unit, Throwable, String] = ModuleMock.ZeroParams
val ZeroParamsWithParens: ModuleMock.Method[Unit, Throwable, String] = ModuleMock.ZeroParamsWithParens
val SingleParam: ModuleMock.Method[Int, Throwable, String] = ModuleMock.SingleParam
val ManyParams: ModuleMock.Method[(Int, String, Long), Throwable, String] = ModuleMock.ManyParams
val ManyParamLists: ModuleMock.Method[(Int, String, Long), Throwable, String] = ModuleMock.ManyParamLists
}

Check
})(anything)
},
test("generates mocks for overloaded pure methods") {
assert({
@mockable[OverloadedPureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[OverloadedPureDefsModule] = ModuleMock

val Overloaded_0: ModuleMock.Effect[Int, String, String] = ModuleMock.Overloaded._0
val Overloaded_1: ModuleMock.Effect[Long, String, String] = ModuleMock.Overloaded._1
}

Check
})(anything)
},
test("generates mocks for overloaded impure methods") {
assert({
@mockable[OverloadedImpureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[OverloadedImpureDefsModule] = ModuleMock

val Overloaded_0: ModuleMock.Method[Int, Throwable, String] = ModuleMock.Overloaded._0
val Overloaded_1: ModuleMock.Method[Long, Throwable, String] = ModuleMock.Overloaded._1
}

Check
})(anything)
},
test("generates mocks for poly pure methods") {
assert({
@mockable[PolyPureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[PolyPureDefsModule] = ModuleMock

val PolyInput: ModuleMock.Poly.Effect.Input[String, String] = ModuleMock.PolyInput
val PolyError: ModuleMock.Poly.Effect.Error[String, String] = ModuleMock.PolyError
val PolyOutput: ModuleMock.Poly.Effect.Output[String, String] = ModuleMock.PolyOutput
val PolyInputError: ModuleMock.Poly.Effect.InputError[String] = ModuleMock.PolyInputError
val PolyInputOutput: ModuleMock.Poly.Effect.InputOutput[String] = ModuleMock.PolyInputOutput
val PolyErrorOutput: ModuleMock.Poly.Effect.ErrorOutput[String] = ModuleMock.PolyErrorOutput
val PolyInputErrorOutput: ModuleMock.Poly.Effect.InputErrorOutput = ModuleMock.PolyInputErrorOutput
val PolyMixed: ModuleMock.Poly.Effect.Output[Unit, String] = ModuleMock.PolyMixed
val PolyBounded: ModuleMock.Poly.Effect.Output[Unit, String] = ModuleMock.PolyBounded
}

Check
})(anything)
},
test("generates mocks for poly impure methods") {
assert({
@mockable[PolyImpureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[PolyImpureDefsModule] = ModuleMock

val PolyInput: ModuleMock.Poly.Method.Input[Throwable, String] = ModuleMock.PolyInput
val PolyError: ModuleMock.Method[String, Throwable, String] = ModuleMock.PolyError
val PolyOutput: ModuleMock.Poly.Method.Output[String, Throwable] = ModuleMock.PolyOutput
val PolyInputError: ModuleMock.Poly.Method.Input[Throwable, String] = ModuleMock.PolyInputError
val PolyInputOutput: ModuleMock.Poly.Method.InputOutput[Throwable] = ModuleMock.PolyInputOutput
val PolyErrorOutput: ModuleMock.Poly.Method.Output[String, Throwable] = ModuleMock.PolyErrorOutput
val PolyInputErrorOutput: ModuleMock.Poly.Method.InputOutput[Throwable] = ModuleMock.PolyInputErrorOutput
val PolyMixed: ModuleMock.Poly.Method.Output[Unit, Throwable] = ModuleMock.PolyMixed
val PolyBounded: ModuleMock.Poly.Method.Output[Unit, Throwable] = ModuleMock.PolyBounded
}

Check
})(anything)
},
test("generates mocks for varargs pure methods") {
assert({
@mockable[VarargsPureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[VarargsPureDefsModule] = ModuleMock

val SimpleVarargs: ModuleMock.Effect[(Int, Seq[String]), String, Int] = ModuleMock.SimpleVarargs
val CurriedVarargs: ModuleMock.Effect[(Int, Seq[String], Long, Seq[Double]), String, Int] =
ModuleMock.CurriedVarargs
}

Check
})(anything)
},
test("generates mocks for varargs impure methods") {
assert({
@mockable[VarargsImpureDefsModule.Service]
object ModuleMock

object Check {
val mock: Mock[VarargsImpureDefsModule] = ModuleMock

val SimpleVarargs: ModuleMock.Method[(Int, Seq[String]), Throwable, String] = ModuleMock.SimpleVarargs
val CurriedVarargs: ModuleMock.Method[(Int, Seq[String], Long, Seq[Double]), Throwable, String] =
ModuleMock.CurriedVarargs
}

Check
})(anything)
}
)
)
}
Loading