小编cmb*_*ter的帖子

我开始在我的项目中使用单元测试,并且正在编写在方法/功能级别进行测试的测试.

我理解这一点,这是有道理的.

但是,什么是集成测试？根据我的阅读,它将测试范围扩展到测试应用程序的更大功能.

这意味着我编写了一个新的测试套件来测试更大的东西,例如(在电子商务网站上)结账功能,用户登录功能,购物篮功能.所以在这里我将编写3个集成测试？

这是否正确 - 如果没有,有人可以解释是什么意思.

此外,集成测试是否涉及ui(此处的Web应用程序上下文),并将使用selenium等自动化.或者是集成测试仍然在代码级别,但是将差异类和代码区域联系在一起.

我一直在玩实验性的Akka Streams API,我有一个用例,我想看看如何实现.对于我的用例,我有一个StreamTcp基于Flow将连接的输入流绑定到我的服务器套接字的源.我拥有的Flow基于ByteString进入它的数据.进入的数据将在其中具有分隔符,这意味着我应该将分隔符之前的所有内容视为一条消息,并将所有内容作为下一条消息处理到下一个分隔符之后.所以玩一个更简单的例子,不使用套接字和静态文本,这就是我提出的:

import akka.actor.ActorSystem
import akka.stream.{ FlowMaterializer, MaterializerSettings }
import akka.stream.scaladsl.Flow
import scala.util.{ Failure, Success }
import akka.util.ByteString

object BasicTransformation {

  def main(args: Array[String]): Unit = {
    implicit val system = ActorSystem("Sys")

    val data = ByteString("Lorem Ipsum is simply.Dummy text of the printing.And typesetting industry.")

    Flow(data).
      splitWhen(c => c == '.').
      foreach{producer => 
        Flow(producer).
          filter(c => c != '.').
          fold(new StringBuilder)((sb, c) => sb.append(c.toChar)).
          map(_.toString).
          filter(!_.isEmpty).
          foreach(println(_)).
          consume(FlowMaterializer(MaterializerSettings()))
      }.
      onComplete(FlowMaterializer(MaterializerSettings())) {
        case any …

我尝试使用Map.map将地图转换为元组列表.然而,这失败了.我做了以下实验:

val m = Map(("a" -> 1), ("b" -> 2))
         //> m  :     scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)
val r1 = m.map{ case (k,v) => v}                //> r1  : scala.collection.immutable.Iterable[Int] = List(1, 2)
def toTuple[A,B](a:A,b:B) = (a,b)               //> toTuple: [A, B](a: A, b: B)(A, B)
//val r2: List[Tuple2[_,_]] = m.map(e => (e._1,e._2))
val r3 = m.map(e => toTuple(e._1,e._2))         //> r3  : scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)
val r4 = m.toSeq                                //> r4  : Seq[(String, …

我正在使用Spray API(spray-client)来访问内部Solr URL,我希望能够将响应解析为Scala案例类.

如果我只是期望和HTTPResponse,我得到一个值,但是当我尝试将它编组到我的case类中时,它失败了(我不能生成除null()以外的消息,因为我正在使用匹配和显然没有得到正确的测试用例.)

我认为我的一些问题是它以数据的形式返回数据text/plain而不是application/json.当我期待HttpResponse而不是我的案例类时,

val f: Future[HttpResponse] =
    (IO(Http) ? Get("http://1.2.3.4:8983/solr/collection1/select?q=*%3A*&wt=json")).mapTo[HttpResponse]

我明白了:

HttpResponse(200 OK,HttpEntity(text/plain; charset=UTF-8,
{
  "responseHeader":{"status":0,"QTime":65,"params":{"q":"*:*","wt":"json"}},
  "response":{"numFound":147437873,"start":0,"maxScore":1.0,"docs":
    [
      {"guid":"TLQ0jVlMYCXQrYkBIZHNXfMmifw+3","alias":["greg"],"_version_":1440942010264453120},
      {"guid":"TQsDY1ZG7q+Ne5e6F7qAUhFyomSH9","_version_":1440942010296958976},
      {"guid":"TzWB5grOBAJJZcAQDo2k9xBUVGPFr","alias":["spark"],"_version_":1440942010298007552},
      {"guid":"T0judCG4UI9RYqDDQVcn+gyZEU7Bb","alias":["zombie"],...),List(Connection: close, Content-Type: text/plain; charset=UTF-8),HTTP/1.1)

但是当我改变它以期待我的案例类时,我无法比拟.那么,我如何编组它返回到Scala案例类的数据呢？这是我尝试过的:

case class SolrParams(q: String, wt: String)
case class SolrResponseHeader(status: String, qtime: String, params: SolrParams)
case class SolrDoc(guid: String, alias: List[String], version: String)
case class SolrResponse(numFound: Long, start: Long, maxScore: String, docs: List[SolrDoc])

case class SolrApResult(responseHeader: SolrResponseHeader, response: SolrResponse)

object SolrJsonProtocol extends DefaultJsonProtocol {
  implicit val paramsFormat = …

我有一个Actor,在某些消息上我正在运行一些返回Future的方法.

 def receive: Receive = {

    case SimpleMessge() =>
        val futData:Future[Int] = ...
        futData.map { data =>
           ... 
        }
}

是否可以通过实际上下文来等待这些数据？或者Await,如果我在SimpleMessage中需要这些数据,我能做的最好吗？

我的代码中有一个场景,我需要Future根据包含特定值的成功结果进行失败.我可以通过这项工作做得很好flatMap,但我想知道是否有更简洁的方法来完成这项工作.首先,一个非常简单的例子:

import concurrent._

case class Result(successful:Boolean)
object FutureTest {
  def main(args: Array[String]) {
    import ExecutionContext.Implicits._

    val f = Future{Result(false)}.flatMap{ result =>
      result match{
        case Result(false) => Promise.failed(new Exception("The call failed!!")).future
        case _ => Promise.successful(result).future
      }
    }

    f onFailure{
      case x => println(x.getMessage())
    }
  }
}

所以在我的例子中,Future如果Result返回的值为false其成功指标,我希望失败.正如我所提到的,我可以使这项工作正常flatMap,但我希望消除的代码行是:

case _ => Promise.successful(result).future

这句话似乎没必要.我想要的行为是能够定义条件,如果它的计算结果为true,那么允许我Future像我一样返回一个不同的东西,但是如果它不是真的,那就把事情保留原样(有点像PartialFunction语义.有没有办法做到这一点,我只是没有看到？我已经看过了collect,transform而且那些看起来也不合适.

编辑

在得到map@Rex Kerr和@senia 的建议之后,我创建了PimpedFuture一个隐式转换,让代码有点像这样:

class …

我正在玩Scala,并试图找出一些关于如何设计类的最佳实践.(一周左右尝试Scala.)

自从我的Erlang时间以来,我是消息传递和基于演员的软件的忠实粉丝.在大多数Scala示例中,actor类的实现方式如下:

object Foo
object Bar
class MyActor extends Actor {
  def receive = {
    case Foo => ...
    case Bar => ...
    case _ => ...
  }
}

但是我从面向对象(接口和多态)载体中学到的东西告诉我这个概念不是很灵活.

MyActor可以被MyAdvancedActor取代,但是没有合约定义MyActor实现需要实现哪些消息.

当我考虑在Scala中编写Actors时,我倾向于编写一个指定某些方法的特征.MyActor实现需要实现此方法,其中可以将自己的私有消息发送给自己.使用这种方法,我们有一个指定的接口,可以以类型安全的方式替换MyActor实现.

在我阅读scala教程和示例的时候,我没有遇到过这样的课程设计.这不是常识,还是有更好的方法在Scala中执行此操作？或者这些教程只是为了涵盖这样一个主题？

使用Akka编写的应用程序需要做哪些扩展(水平扩展)？粗略地说,为了在集群中添加新节点,我是否只需要在其上安装JRE并.jar使用我的Akka-client应用程序运行文件？

当运行以下akka流式传输FlowGraph时,并非所有发出的Chars都被所有接收器接收.

package sample.stream

import java.io.{ FileOutputStream, PrintWriter }
import akka.actor.ActorSystem
import akka.stream.ActorFlowMaterializer
import akka.stream.scaladsl.{ Broadcast, FlowGraph, Sink, Source }
import scala.concurrent.forkjoin.ThreadLocalRandom
import scala.util.{ Failure, Success, Try }

object Sample {

  def main(args: Array[String]): Unit = {
    println("start")
    implicit val system = ActorSystem("Sys")
    import system.dispatcher
    implicit val materializer = ActorFlowMaterializer()
    var counter = -1

    val countSource: Source[Char, Unit] = Source(() => Iterator.continually { counter += 1; (counter + 'A').toChar }.take(11))

    var counter1 = 0
    val consoleSink1 = Sink.foreach[Char] { counter => …

我注意到编写这段scala代码是合法的:

val fussyActor = actor {
  loop {
    receive {
      case s: String => println("I got a String: " + s)
      case _ => println("I have no idea what I just got.")
    }
  }
}

我知道,从文档即actor是一个特点,它具有loop和receive值的成员.但是如何像上面那样堆叠这些方法呢？它是在实施还是重写这些方法？我对这种语法很困惑.请提供一些很好的参考/指针.

我们目前有这样的代码

def somemethod() : Future[Resp] = {
   val responseFuture = service.serveV2(req)
   val nextFuture = responseFuture flatMap {
       //do something on success including call to next async service
   }
   nextFuture
}

当然,超时时会跳过映射,但我需要将该超时转换为适当的异常,我可以将其传递给我们的Web框架以返回正确的响应代码.如何在scala中执行此操作？

另外值得注意的是,我需要回归那个未来.也许我应该在responseFuture.onFailure中创建一个承诺和连接到那个承诺,还是我完全不在这里？(我想知道是否有一种更简单的方法,或者我可以尝试沿着这条路走下去).