Tests that pass when something is actually broken, and fail when things actually do work, are worse than useless- they are positively harmful.
Let's say we've been tasked with returning 400 when GET /users/<userId> is called with a negative userId.
The requirement can be turned into a test that hits the endpoint with a negative userId and checks that a 400 is returned:
| import cats.{Applicative, Contravariant, Functor} | |
| import cats.implicits._ | |
| implicit def covariance[F[_]: Functor, A, B >: A](fa: F[A]): F[B] = | |
| fa.widen | |
| implicit def contravariance[F[_]: Contravariant, A, B <: A](fa: F[A]): F[B] = | |
| fa.narrow | |
| def test[F[_]: Applicative, A](a: A) = { |
| import zio.{Task, ZIO } | |
| trait ConfigModule { | |
| def configService: ConfigService | |
| } | |
| trait ConfigService { | |
| def config: Task[String] | |
| } |
| /* Example of encoding Functor/Applicative/Monad from cats with Dotty 0.15 features. | |
| * Derived in part from Cats -- see https://github.com/typelevel/cats/blob/master/COPYING for full license & copyright. | |
| */ | |
| package structures | |
| import scala.annotation._ | |
| trait Functor[F[_]] { | |
| def (fa: F[A]) map[A, B](f: A => B): F[B] | |
| def (fa: F[A]) as[A, B](b: B): F[B] = |
| ### JHW 2018 | |
| import numpy as np | |
| import umap | |
| # This code from the excellent module at: | |
| # https://stackoverflow.com/questions/4643647/fast-prime-factorization-module | |
| import random |
| WAYLAND_PROTOCOLS=/usr/share/wayland-protocols | |
| # wayland-scanner is a tool which generates C headers and rigging for Wayland | |
| # protocols, which are specified in XML. wlroots requires you to rig these up | |
| # to your build system yourself and provide them in the include path. | |
| xdg-shell-protocol.h: | |
| wayland-scanner server-header \ | |
| $(WAYLAND_PROTOCOLS)/stable/xdg-shell/xdg-shell.xml $@ | |
| xdg-shell-protocol.c: xdg-shell-protocol.h |
| {-| | |
| - Example of using free constructions to build a flexible little compiler. | |
| - | |
| - The goal here is not necessarily efficiency but readability and flexibility. | |
| - | |
| - The language grammar is represented by an ADT; however, instead of | |
| - recursively referring to itself it instead references a type variable. | |
| - | |
| - We derive instances of 'Functor' and 'Traversable' for this type. | |
| - |
| /* variation on https://medium.com/@DanHomola/react-higher-order-components-in-typescript-made-simple-6f9b55691af1 */ | |
| import * as React from 'react' | |
| import { wrapDisplayName } from 'recompose' | |
| // Props you want the resulting component to take (besides the props of the wrapped component) | |
| interface ExternalProps {} | |
| // Props the HOC adds to the wrapped component | |
| export interface InjectedProps {} |
| /* | |
| * Copyright (c) 2019 Michael Krane | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining | |
| * a copy of this software and associated documentation files (the | |
| * "Software"), to deal in the Software without restriction, including | |
| * without limitation the rights to use, copy, modify, merge, publish, | |
| * distribute, sublicense, and/or sell copies of the Software, and to | |
| * permit persons to whom the Software is furnished to do so, subject to | |
| * the following conditions: |
| sealed trait Decidable[+Proof] | |
| final case class Yes[Proof](proof: Proof) extends Decidable[Proof] | |
| final case object No extends Decidable[Nothing] | |
| sealed trait List[+A] { | |
| def nonEmpty: Decidable[this.type <:< ::[A]] | |
| def ::[AA >: A](value: AA): ::[AA] = new ::[AA](value, this) | |
| } | |
| final case object Nil extends List[Nothing] { | |
| def nonEmpty: Decidable[this.type <:< ::[Nothing]] = No |
