//设置package包名称以及导入依赖的类
package test

import org.scalatest.{FeatureSpec, GivenWhenThen}

class AppSpec extends FeatureSpec with GivenWhenThen {

  info("As an app developer I want to be able to access the app, its settings and properties")

  feature("Application class") {
    scenario("can be instantiated in Headless mode") {
      Given("a default location app.Main for the app")
      When("the class is instantiated as a headless")
      val application = new app.Main(true)
      Then("the object should be instantiated")
      assert(application.isInstanceOf[app.Main])
    }
  }
} 

//设置package包名称以及导入依赖的类
import org.scalatest.{FeatureSpec, GivenWhenThen}


class ReadFromFileSpec extends FeatureSpec with GivenWhenThen {

  info("As a user from PSP1")
  info("I want to calculate the mean of a file compound by decimal numbers")
  info("So I don't have to type them manually")
  info("And save my time")

  feature("Calculate mean") {
    scenario("User sends a file with the numbers, one per line") {
      val fileName = getClass.getResource("test.txt").getFile
      Given("the file is not empty")
      assert(scala.io.Source.fromFile(fileName).getLines().nonEmpty)
      Given("the file has just numbers")
      assert(!scala.io.Source.fromFile(fileName).getLines().exists(!ReadFromFile.isAllDigits(_)))
      When("the mean is calculated for that file")
      val list = ReadFromFile.getListFromFile(fileName)
      val mean = list.mean
      Then("the result should be a decimal number")
      assert(mean.isInstanceOf[Double])
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.ubirch.avatar.transformer.services

import com.typesafe.scalalogging.slf4j.StrictLogging
import com.ubirch.transformer.services.PtxTransformerService
import com.ubirch.util.json.MyJsonProtocol
import org.scalatest.{FeatureSpec, Matchers}


class PtxTrackleTransformerServiceTest extends FeatureSpec
  with Matchers
  with StrictLogging
  with MyJsonProtocol {

  feature("PTX") {
    scenario("temp gt 0") {
      val adc1: BigDecimal = 21285.0
      val t1: BigDecimal = 24.69

      PtxTransformerService.pt100_temperature(adc = adc1).setScale(2, BigDecimal.RoundingMode.HALF_UP) shouldBe t1
    }

    scenario("temp lt 0") {
      val adc1: BigDecimal = 10.0
      val t1: BigDecimal = -241.91

      PtxTransformerService.pt100_temperature(adc = adc1).setScale(2, BigDecimal.RoundingMode.HALF_UP) shouldBe t1
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.reactivecore.quotes.workshop.api.feature

import com.reactivecore.quotes.workshop.api.QuotesWorkshopApiService
import org.scalatest.concurrent.{PatienceConfiguration, ScalaFutures}
import org.scalatest.time.{Seconds, Span}
import org.scalatest.{FeatureSpec, GivenWhenThen, Matchers}
import play.api.http.Status

class HealthCheckFeature extends FeatureSpec with GivenWhenThen with Matchers with ScalaFutures with PatienceConfiguration {

  override implicit val patienceConfig = PatienceConfig(
    timeout = scaled(Span(1, Seconds))
  )

  feature("health check") {
    scenario("service is healthy") {
      Given("a service")
      val service = QuotesWorkshopApiService()

      When("getting the /health endpoint")
      val response = get(s"http://localhost:${service.port}/health").futureValue

      Then("the response status should be OK")
      response.status should be(Status.OK)

      service.stop()
    }
  }

} 

//设置package包名称以及导入依赖的类
package com.reactivecore.quotes.workshop.api.feature

import com.reactivecore.quotes.workshop.api.QuotesWorkshopApiService
import org.scalatest.concurrent.{PatienceConfiguration, ScalaFutures}
import org.scalatest.time.{Seconds, Span}
import org.scalatest.{FeatureSpec, GivenWhenThen, Matchers}
import play.api.http.Status

class OptionsFeature extends FeatureSpec with GivenWhenThen with Matchers with ScalaFutures with PatienceConfiguration {

  override implicit val patienceConfig = PatienceConfig(
    timeout = scaled(Span(1, Seconds))
  )

  feature("options") {
    scenario("requests options of /items") {
      Given("a service")
      val service = QuotesWorkshopApiService()

      When("requesting for the options of /items endpoint")
      val response = options(s"http://localhost:${service.port}/items").futureValue

      Then("the response status should be OK")
      response.status should be(Status.OK)

      service.stop()
    }
  }

} 

//设置package包名称以及导入依赖的类
package org.akka.templates.features

import akka.http.scaladsl.model.StatusCodes
import akka.http.scaladsl.server.Route
import akka.http.scaladsl.testkit.ScalatestRouteTest
import org.akka.templates.endpoints.GreetingEndpoint
import org.scalatest.{FeatureSpec, Matchers}
import org.akka.templates.response.rejection._


class GreetingEndpointFeature
  extends FeatureSpec
    with Matchers
    with ScalatestRouteTest
    with GreetingEndpoint {

  feature("greeting api") {
    scenario("successful get") {
      Get(s"/api/greetings?name=gabriel&greeting=hello") ~> Route.seal(apiRoute) ~> check {
        status shouldBe StatusCodes.OK
        responseAs[String] should include (s"hello, gabriel")
      }
    }

    scenario("unprocessable entity get") {
      Get(s"/api/greetings?name=gabriel&greeting=") ~> Route.seal(apiRoute) ~> check {
        status shouldBe StatusCodes.UnprocessableEntity
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.stulsoft.pscalatest.prod.integrationTest

import com.stulsoft.pscalatest.prod.Prod1

import org.scalatest.{FeatureSpec, GivenWhenThen}


class Prod1FeatureTest extends FeatureSpec with GivenWhenThen {
  info("As owner")
  info("I want increase age")
  info("So I can increase age when I want")
  feature("Prod1") {
    scenario("Increasing p1") {
      Given("a Prod1 object with p1 = 1")
      val p = Prod1(1, "test")
      When("increase p1 by 1")
      p.incrementP1(1)
      Then("p1 must be 2")
      assert(p.p1 == 2)
    }
  }
} 

//设置package包名称以及导入依赖的类
package br.com.uol.plataforma.event.sourcing

import java.util.UUID

import br.com.uol.plataforma.event.sourcing.commands.BankAccountCommands._
import br.com.uol.plataforma.event.sourcing.model.{Event, Request}
import br.com.uol.plataforma.event.sourcing.player.EventPlayer._
import br.com.uol.plataforma.event.sourcing.state.BankAccount
import br.com.uol.plataforma.event.sourcing.store.BankAccountEventStore.eventStore
import org.scalatest.{FeatureSpec, Matchers}


class EventSourcingTest extends FeatureSpec with Matchers {
  feature("Creating an account and then closing it") {
    scenario("Create an account and then assert that replay restores the actual state of the BankAccount object") {
      val aggregationId = UUID.randomUUID().toString

      val f =
        createAccount(Request("owner" -> "John Doe", "id" -> 123))
          .andThen(deposit(Request("amount" -> 20)))
          .andThen(changeOwner(Request("newOwner" -> "Jane Doe")))
          .andThen(withdrawal(Request("amount" -> 10)))
          .andThen(close(Request("reason" -> "Unavailable address")))

      val actualState: BankAccount = f(BankAccount(aggregationId))
      val events: Seq[Event[BankAccount]] = eventStore.get(aggregationId)
      val playedState: BankAccount = events.play(BankAccount(aggregationId))

      actualState shouldEqual playedState
    }
  }
} 

//设置package包名称以及导入依赖的类
package scorex.network

import java.net.{InetAddress, InetSocketAddress}

import com.typesafe.config.ConfigFactory
import com.wavesplatform.network.PeerDatabaseImpl
import com.wavesplatform.settings.NetworkSettings
import net.ceedubs.ficus.Ficus._
import org.scalatest.{FeatureSpec, GivenWhenThen}

class BlacklistSpecification extends FeatureSpec with GivenWhenThen {
  private val config = ConfigFactory.parseString(
    """waves.network {
      |  known-peers = []
      |  file = null
      |  black-list-residence-time: 1s
      |}""".stripMargin).withFallback(ConfigFactory.load()).resolve()

  private val networkSettings = config.as[NetworkSettings]("waves.network")

  info("As a Peer")
  info("I want to blacklist other peers for certain time")
  info("So I can give them another chance after")

  feature("Blacklist") {
    scenario("Peer blacklist another peer") {

      Given("Peer database is empty")
      val peerDatabase = new PeerDatabaseImpl(networkSettings)

      def isBlacklisted(address: InetSocketAddress) = peerDatabase.blacklistedHosts.contains(address.getAddress)

      assert(peerDatabase.knownPeers.isEmpty)
      assert(peerDatabase.blacklistedHosts.isEmpty)

      When("Peer adds another peer to knownPeers")
      val address = new InetSocketAddress(InetAddress.getByName("localhost"), 1234)
      peerDatabase.touch(address)
      assert(peerDatabase.knownPeers.contains(address))
      assert(!isBlacklisted(address))

      And("Peer blacklists another peer")
      peerDatabase.blacklist(address.getAddress)
      assert(isBlacklisted(address))
      assert(!peerDatabase.knownPeers.contains(address))

      And("Peer waits for some time")
      Thread.sleep(networkSettings.blackListResidenceTime.toMillis + 500)

      Then("Another peer disappear from blacklist")
      assert(!isBlacklisted(address))

      And("Another peer became known")
      assert(peerDatabase.knownPeers.contains(address))
    }
  }
} 

//设置package包名称以及导入依赖的类
package repositories

import domain.Guarantee
import org.scalatest.{FeatureSpec, GivenWhenThen}

import scala.concurrent.Await


class GuaranteeRepositoryTest extends FeatureSpec with GivenWhenThen{

  feature("Create guarantee") {
    info("Add guarantee")
    scenario("Add new guarantee ") {
      Given("Given all data")
      val guaranteeId = "12345678"
      val amount = 120000
      val currency = "US"

      Then("Add guarantee ")
      val guarantee = Guarantee(guaranteeId, amount, currency)
      val guaranteeRepo = GuaranteeRepository
      guaranteeRepo.save(guarantee)
      Then("Display All ")
      val displayAllGuarantee = Await.result(guaranteeRepo.getGuaranteeById(guaranteeId), 2 minutes)
      displayAllGuarantee.foreach(i => println("Guarantee=======>", i))
      val displayIdStatus = Await.result(guaranteeRepo.getGuaranteeById(guaranteeId), 2 minutes)
      displayIdStatus.foreach(i => println("GuaranteeStatus=======>", i))
    }
  }
} 

//设置package包名称以及导入依赖的类
package repositories

import domain.Feature
import org.scalatest.{FeatureSpec, GivenWhenThen}


class FeatureRepositoryTest extends FeatureSpec with GivenWhenThen{

  feature("Create feature") {
    info("Add an feature")
    scenario("Add new feature ") {
      Given("Given all data")
      val featureId = "123456"
      val code = "code"
      val featureOf = "featureOf"
      val relatedItem = "relatedItem"
      val title = "title"
      val description = "description"
      val enum = "featurevalue"

      Then("Add feature ")
      val feature = Feature(featureId, code, featureOf, relatedItem, title, description, enum)
      val featureRepo = FeatureRepository
      featureRepo.save(feature)
      Then("Display All ")
      val displayAllcancelled = Await.result(featureRepo.getFeatureById(featureId), 2 minutes)
      displayAllfeature.foreach(i => println("Feature=======>", i))
      val displayIdStatus = Await.result(featureRepo.getFeatureById(featureId), 2 minutes)
      displayIdStatus.foreach(i => println("FeatureStatus=======>", i))
    }
    }
  } 

//设置package包名称以及导入依赖的类
package repositories

import domain.Cancellation
import org.scalatest.{FeatureSpec, GivenWhenThen}
import repositories.CancellationRepository

import scala.concurrent.Await


class CancellationRepositoryTest extends FeatureSpec with GivenWhenThen {

  feature("Create cancellation") {
    info("Add an cancellation")
    scenario("Add new cancellation ") {
      Given("Given cancellationId,reason,date,status,document,cancellationOf,relatedLot")
      val cancellationId = "12345"
      val reason = "Nothing"
      val date = "26/18/12"
      val status = "Done"
      val documents = "Documnets"
      val cancellationOf = "Bond"
      val relatedLot = "related"

      Then("Add cancellation ")
      val cancellation = Cancellation(cancellationId,reason,date,status,documents,cancellationOf,cancellationOf,relatedLot)
      val cancellationRepo = CancellationRepository
      cancellationRepo.save(cancellation)
      Then("Display All ")
      val displayAllcancelled = Await.result(cancellationRepo.getCancellationById(cancellationId), 2 minutes)
      displayAllcancelled.foreach(i => println("Cancellation=======>", i))
      val displayIdStatus = Await.result(cancellationRepo.getCancellationById(cancellationId), 2 minutes)
      displayIdStatus.foreach(i => println("CancellationStatus=======>", i))
    }
  }

} 

//设置package包名称以及导入依赖的类
package repositories

import domain.{Revision}
import org.scalatest.{FeatureSpec, GivenWhenThen}

import scala.collection.mutable
import scala.concurrent.Await


class RevisionRepositoryTest extends FeatureSpec with GivenWhenThen{

  feature("Create revision") {
    info("Add revision")
    scenario("Add new revision ") {
      Given("Given all data")
      val revisionId = "12345678"
      val date = "25/12/2016"
      val changes = mutable.MutableList[Object]()

      Then("Add guarantee ")
      val revision = Revision(revisionId, date, changes)
      val revisionRepo = RevisionRepository
      revisionRepo.save(revision)
      Then("Display All ")
      val displayAllRevision= Await.result(revisionRepo.getGuaranteeById(revisionId), 2 minutes)
      displayAllRevision.foreach(i => println("Revision=======>", i))
      val displayIdStatus = Await.result(revisionRepo.getGuaranteeById(revisionId), 2 minutes)
      displayIdStatus.foreach(i => println("RevisionStatus=======>", i))
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.microsoft.azure.iot.iothubreact.checkpointing

import com.microsoft.azure.iot.iothubreact.checkpointing.backends.cassandra.lib.Auth
import com.typesafe.config.{Config, ConfigException}
import org.mockito.Mockito._
import org.scalatest.mockito.MockitoSugar
import org.scalatest.{FeatureSpec, GivenWhenThen}

class ConfigurationTest extends FeatureSpec with GivenWhenThen with MockitoSugar {

  info("As a configured instance")
  info("I want logic around returned values to be consistent with application expectations")

  val confPath = "iothub-react.checkpointing."
  Feature("Configuration Cassandra authorization") {

    Scenario("Only one of username or password is supplied") {
      var cfg = mock[Config]
      when(cfg.getString(confPath + "storage.cassandra.username")).thenReturn("username")
      when(cfg.getString(confPath + "storage.cassandra.password")).thenThrow(new ConfigException.Missing("path"))
      assert(new CPConfiguration(cfg).cassandraAuth == None)

      cfg = mock[Config]
      when(cfg.getString(confPath + "storage.cassandra.username")).thenThrow(new ConfigException.Missing("path"))
      when(cfg.getString(confPath + "storage.cassandra.password")).thenReturn("password")
      assert(new CPConfiguration(cfg).cassandraAuth == None)
    }

    Scenario("Both username and password are supplied") {
      var cfg = mock[Config]
      when(cfg.getString(confPath + "storage.cassandra.username")).thenReturn("username")
      when(cfg.getString(confPath + "storage.cassandra.password")).thenReturn("password")
      assert(new CPConfiguration(cfg).cassandraAuth == Some(Auth("username", "password")))
    }
  }

  Feature("Storage namespace") {

    Scenario("Cassandra has a special namespace value") {
      var cfg = mock[Config]
      when(cfg.getString(confPath + "storage.namespace")).thenReturn("")

      when(cfg.getString(confPath + "storage.backendType")).thenReturn("anythingbutcassandra")
      assert(new CPConfiguration(cfg).storageNamespace == "iothub-react-checkpoints")

      when(cfg.getString(confPath + "storage.backendType")).thenReturn("AZUREBLOB")
      assert(new CPConfiguration(cfg).storageNamespace == "iothub-react-checkpoints")

      when(cfg.getString(confPath + "storage.backendType")).thenReturn("CASSANDRA")
      assert(new CPConfiguration(cfg).storageNamespace == "iothub_react_checkpoints")
    }
  }
} 

//设置package包名称以及导入依赖的类
// Copyright (c) Microsoft. All rights reserved.

package com.microsoft.azure.iot.iothubreact.checkpointing

import com.microsoft.azure.iot.iothubreact.checkpointing.backends.cassandra.lib.Auth
import com.typesafe.config.{Config, ConfigException}
import org.mockito.Mockito._
import org.scalatest.mockito.MockitoSugar
import org.scalatest.{FeatureSpec, GivenWhenThen}

class CPConfigurationTest extends FeatureSpec with GivenWhenThen with MockitoSugar {

  info("As a configured instance")
  info("I want logic around returned values to be consistent with application expectations")

  val confPath = "iothub-react.checkpointing."
  Feature("Configuration Cassandra authorization") {

    Scenario("Only one of username or password is supplied") {
      var cfg = mock[Config]
      when(cfg.getString(confPath + "storage.cassandra.username")).thenReturn("username")
      when(cfg.getString(confPath + "storage.cassandra.password")).thenThrow(new ConfigException.Missing("path"))
      assert(new CPConfiguration(cfg).cassandraAuth == None)

      cfg = mock[Config]
      when(cfg.getString(confPath + "storage.cassandra.username")).thenThrow(new ConfigException.Missing("path"))
      when(cfg.getString(confPath + "storage.cassandra.password")).thenReturn("password")
      assert(new CPConfiguration(cfg).cassandraAuth == None)
    }

    Scenario("Both username and password are supplied") {
      var cfg = mock[Config]
      when(cfg.getString(confPath + "storage.cassandra.username")).thenReturn("username")
      when(cfg.getString(confPath + "storage.cassandra.password")).thenReturn("password")
      assert(new CPConfiguration(cfg).cassandraAuth == Some(Auth("username", "password")))
    }
  }

  Feature("Storage namespace") {

    Scenario("Cassandra has a special namespace value") {
      var cfg = mock[Config]
      when(cfg.getString(confPath + "storage.namespace")).thenReturn("")

      when(cfg.getString(confPath + "storage.backendType")).thenReturn("anythingbutcassandra")
      assert(new CPConfiguration(cfg).storageNamespace == "iothub-react-checkpoints")

      when(cfg.getString(confPath + "storage.backendType")).thenReturn("AZUREBLOB")
      assert(new CPConfiguration(cfg).storageNamespace == "iothub-react-checkpoints")

      when(cfg.getString(confPath + "storage.backendType")).thenReturn("CASSANDRA")
      assert(new CPConfiguration(cfg).storageNamespace == "iothub_react_checkpoints")
    }
  }
} 

//设置package包名称以及导入依赖的类
package desafio

import main.scala.desafio.SparkBirthdays
import org.scalatest.{FeatureSpec, GivenWhenThen}


class SparkBirthdays$Test extends FeatureSpec with GivenWhenThen {

  feature("Calling main method when there are no application.config file"){
    scenario("Not passing any input CSV file nor output path"){
      assertThrows[Exception] {
        SparkBirthdays.main(Array[String]())
      }
    }
    scenario("Not passing any input CSV file but passing output path"){
      assertThrows[Exception] {
        SparkBirthdays.main(Array("Out.json"))
      }

    }
    scenario("Passing an MISSING input CSV and output path"){
      assertThrows[Exception] {
        SparkBirthdays.main(Array("data/NonExisting.csv", "Out.json"))
      }
    }
    scenario("Passing both input CSV and output path"){
      SparkBirthdays.main(Array("data/Mock.csv","Out.json"))
    }
  }
} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.fileupload.support

import java.util.UUID

import org.scalatest.concurrent.{Eventually, ScalaFutures}
import org.scalatest.{BeforeAndAfterEach, FeatureSpec, GivenWhenThen, Matchers}
import play.api.http.Status
import uk.gov.hmrc.fileupload.read.envelope.Repository
import uk.gov.hmrc.mongo.MongoSpecSupport

import scala.concurrent.ExecutionContext.Implicits._

trait IntegrationSpec extends FeatureSpec with GivenWhenThen  with ScalaFutures
  with Matchers with Status with Eventually with FakeConsumingService
  with BeforeAndAfterEach with MongoSpecSupport {

  val nextId = () => UUID.randomUUID().toString

  override def beforeEach {
    new Repository(mongo).removeAll().futureValue
  }

  override def afterAll {
    mongo.apply().drop.futureValue
  }
} 

//设置package包名称以及导入依赖的类
package toguru.api

import org.scalatest.mockito.MockitoSugar
import org.scalatest.{FeatureSpec, _}
import toguru.api.Activations.Provider

class ToguruClientSpec extends FeatureSpec with MustMatchers with MockitoSugar {

  val mockClientInfo = ClientInfo()

  val mockClientProvider: ClientInfo.Provider[String] = _ => mockClientInfo

  def activationProvider(activations: Activations = DefaultActivations, health: Boolean): Activations.Provider =
    new Provider {
      def healthy() = health
      def apply() = activations
    }

  def toguruClient(clientProvider: ClientInfo.Provider[String] = mockClientProvider, activations: Activations.Provider) =
    new ToguruClient(clientProvider, activations)


  feature("health check") {
    scenario("activations provider is healthy") {
      val client = toguruClient(activations = activationProvider(health = true))

      client.healthy() mustBe true
    }

    scenario("activations provider is unhealthy") {
      val client = toguruClient(activations = activationProvider(health = false))

      client.healthy() mustBe false
    }
  }

  feature("client info provider") {
    scenario("client info requested") {
      val myActivations = mock[Activations]
      val myInfo: ClientInfo = ClientInfo().withAttribute("user", "me")
      val client = toguruClient(
        clientProvider = _ => myInfo,
        activations = activationProvider(health = true, activations = myActivations))

      val toggling = client.apply("client")

      toggling.activations mustBe myActivations
      toggling.client mustBe myInfo
    }
  }
} 

//设置package包名称以及导入依赖的类
package toguru.api

import org.scalatest.{FeatureSpec, _}

class ConditionSpec extends FeatureSpec with MustMatchers {

  feature("Off Condition") {
    scenario("can be created by API") {
      Condition.Off mustBe a[Condition]
    }
  }

  feature("On Condition") {
    scenario("can be created") {
      Condition.On mustBe a[Condition]
    }
  }

  feature("Rollout Range Condition") {
    scenario("can be created") {
      Condition.UuidRange(1 to 20) mustBe a[Condition]
    }
  }

  feature("Attribute Condition") {
    scenario("can be created") {
      Condition.Attribute("myAttribute", "one", "two", "three") mustBe a[Condition]
    }
  }

  feature("Combined Condition") {
    scenario("can be created") {
      import Condition._
      Condition(
        UuidRange(1 to 20),
        Attribute("myAttribute", "one", "two", "three")) mustBe a[Condition]
    }

    scenario("when created from one condition yields the given condition") {
      Condition(Condition.Off) mustBe Condition.Off
    }

    scenario("when created from empty conditions yields Condition 'On'") {
      Condition() mustBe Condition.On
    }
  }
} 

//设置package包名称以及导入依赖的类
package toguru.api

import org.scalatest.{FeatureSpec, MustMatchers}
import toguru.test.TestActivations

class ToggleSpec extends FeatureSpec with MustMatchers {

  val emptyToggleInfo = TogglingInfo(ClientInfo(), new TestActivations.Impl()())

  feature("Toggle creation") {
    scenario("default condition is false") {
      val toggle1 = Toggle("toggle-1")
      implicit val toggleInfo = emptyToggleInfo

      toggle1.isOn mustBe false
      toggle1.isOff mustBe true
    }

    scenario("default condition is respected") {
      val toggle1 = Toggle("toggle-1", default = Condition.On)
      implicit val toggleInfo = emptyToggleInfo

      toggle1.isOn mustBe true
      toggle1.isOff mustBe false
    }
  }
}