Merge pull request #2 from travisbrown/topics/updates-and-tests

Update versions and add some tests

build.sbt

@@ -1,8 +1,8 @@
 import ScoverageSbtPlugin.ScoverageKeys.coverageExcludedPackages
 
 val bijectionVersion = "0.7.2"
-val utilVersion = "6.23.0"
-val finagleVersion = "6.24.0"
+val utilVersion = "6.24.0"
+val finagleVersion = "6.25.0"
 
 lazy val buildSettings = Seq(
   organization := "io.catbird",

finagle/src/test/scala/io/catbird/finagle/ServiceTests.scala

@@ -1,9 +1,12 @@
 package io.catbird.finagle
 
+import cats.data.Kleisli
+import com.twitter.bijection.InversionFailure
 import com.twitter.finagle.Service
 import com.twitter.util.Future
+import io.catbird.util._
 import org.scalatest.FunSuite
-import scala.util.Success
+import scala.util.{ Failure, Success }
 
 /**
  * TODO: real tests
@@ -16,4 +19,15 @@ class ServiceTests extends FunSuite with ServiceConversions {
 
     assert(Success(service) === serviceToKleisli.invert(serviceToKleisli(service)))
   }
+
+  test("Non-Service Kleisli[Future, Int, String] should fail with an InversionFailure") {
+    val kleisli: Kleisli[Future, Int, String] = Kleisli.kleisliArrow[Future].lift(_.toString)
+
+    assert(
+      serviceToKleisli.invert(kleisli) match {
+        case Failure(InversionFailure(_, _)) => true
+        case _ => false
+      }
+    )
+  }
 }

util/src/test/scala/io/catbird/util/FutureTests.scala → util/src/test/scala/io/catbird/util/future.scala

@@ -10,13 +10,14 @@ import io.catbird.test.util.ArbitraryKInstances
 import org.scalatest.FunSuite
 import org.typelevel.discipline.scalatest.Discipline
 
-class FutureTests extends FunSuite with Discipline
+class FutureSuite extends FunSuite with Discipline
   with FutureInstances with ArbitraryKInstances {
   implicit val eqv: Eq[Future[Int]] = futureEq(1.second)
   implicit val comonad: Comonad[Future] = futureComonad(1.second)
 
   checkAll("Future[Int]", MonadTests[Future].monad[Int, Int, Int])
   checkAll("Future[Int]", ComonadTests[Future].comonad[Int, Int, Int])
+  checkAll("Future[Int]", FunctorTests[Future](comonad).functor[Int, Int, Int])
   checkAll("Future[Int]", GroupLaws[Future[Int]].semigroup(futureSemigroup[Int]))
   checkAll("Future[Int]", GroupLaws[Future[Int]].monoid)
 }

util/src/test/scala/io/catbird/util/try.scala

@@ -0,0 +1,37 @@
+package io.catbird.util
+
+import algebra.laws.GroupLaws
+import cats.data.Xor
+import cats.laws.discipline.arbitrary._
+import cats.std.int._
+import cats.std.string._
+import com.twitter.util.{ Return, Throw, Try }
+import io.catbird.test.bijection.BijectionProperties
+import io.catbird.test.util.ArbitraryInstances
+import org.scalatest.prop.{ Checkers, PropertyChecks }
+import org.scalatest.{ FunSuite, PropSpec }
+import org.typelevel.discipline.scalatest.Discipline
+
+trait TryTest extends ArbitraryInstances with TryConversions with TryInstances
+
+class TrySuite extends FunSuite with TryTest with Discipline {
+  checkAll("Try[Int]", GroupLaws[Try[Int]].semigroup(trySemigroup[Int]))
+  checkAll("Try[Int]", GroupLaws[Try[Int]].monoid)
+}
+
+class TrySpec extends PropSpec with PropertyChecks with Checkers
+  with TryTest with BijectionProperties {
+  check {
+    isBijection[Try[String], Xor[Throwable, String]]
+  }
+
+  property("Equality for Try should use universal equality for Throw") {
+    case class SomeError(message: String) extends Exception(message)
+
+    forAll((s: String) => assert(tryEq[Int].eqv(Throw(SomeError(s)), Throw(SomeError(s)))))
+  }
+
+  property("Equality for Try should never mix up Return and Throw") {
+    forAll((i: Int) => assert(!tryEq[Int].eqv(Throw(new Exception), Return(i))))
+  }
+}

util/src/test/scala/io/catbird/util/VarTests.scala → util/src/test/scala/io/catbird/util/var.scala

@@ -9,13 +9,14 @@ import io.catbird.test.util.ArbitraryKInstances
 import org.scalatest.FunSuite
 import org.typelevel.discipline.scalatest.Discipline
 
-class VarTests extends FunSuite with Discipline
+class VarSuite extends FunSuite with Discipline
   with VarInstances with ArbitraryKInstances {
   implicit val eqv: Eq[Var[Int]] = varEq
   implicit val comonad: Comonad[Var] = varComonad
 
   checkAll("Var[Int]", MonadTests[Var].monad[Int, Int, Int])
   checkAll("Var[Int]", ComonadTests[Var].comonad[Int, Int, Int])
+  checkAll("Var[Int]", FunctorTests[Var](comonad).functor[Int, Int, Int])
   checkAll("Var[Int]", GroupLaws[Var[Int]].semigroup(varSemigroup[Int]))
   checkAll("Var[Int]", GroupLaws[Var[Int]].monoid)
 }