Fix tests

Author: jiangpengcheng

common/scala/src/main/scala/org/apache/openwhisk/core/entity/WhiskAction.scala

@@ -490,11 +490,7 @@ object WhiskAction extends DocumentFactory[WhiskAction] with WhiskEntityQueries[
             old)
       }
     } match {
-      case Success(f) =>
-        implicit val ec = db.executionContext
-        implicit val logger = db.logging
-        WhiskActionVersionList.deleteCache(doc.fullyQualifiedName(false))
-        f
+      case Success(f) => f
       case Failure(f) => Future.failed(f)
     }
   }

core/controller/src/main/scala/org/apache/openwhisk/core/controller/Actions.scala

@@ -234,6 +234,9 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
               case Success(id) =>
                 putEntity(WhiskAction, entityStore, id, true, update(user, request) _, () => {
                   make(user, entityName, request)
+                }, postProcess = Some { action: WhiskAction =>
+                  WhiskActionVersionList.deleteCache(entityName)
+                  complete(OK, action)
                 })
               case Failure(f) =>
                 terminate(InternalServerError)
@@ -354,11 +357,18 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
     parameter('version.as[SemVer] ?) { version =>
       onComplete(WhiskActionVersionList.get(entityName, entityStore)) {
         case Success(results) =>
-          WhiskActionVersionList.deleteCache(entityName) // invalidate version list cache at all cases
           version match {
             case Some(_) =>
               val docId = results.matchedDocId(version).getOrElse(entityName.toDocId)
-              deleteEntity(WhiskAction, entityStore, docId, (a: WhiskAction) => Future.successful({}))
+              deleteEntity(
+                WhiskAction,
+                entityStore,
+                docId,
+                (a: WhiskAction) => Future.successful({}),
+                postProcess = Some { action: WhiskAction =>
+                  WhiskActionVersionList.deleteCache(entityName)
+                  complete(OK, action)
+                })
             case None =>
               val fs =
                 if (results.versions.isEmpty)
@@ -372,7 +382,13 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
                         WhiskAction.del(entityStore, entity.docinfo).map(_ => entity)
                       }
                     }
-              onComplete(Future.sequence(fs)) {
+              val deleteFuture = Future.sequence(fs).andThen {
+                case _ =>
+                  WhiskActionVersionList
+                    .deleteCache(entityName) // invalidate version list cache after all deletion completed
+              }
+
+              onComplete(deleteFuture) {
                 case Success(entities) =>
                   complete(OK, entities.last)
                 case Failure(t: NoDocumentException) =>

core/controller/src/main/scala/org/apache/openwhisk/core/controller/Packages.scala

@@ -85,15 +85,25 @@ trait WhiskPackagesApi extends WhiskCollectionAPI with ReferencedEntities {
           }
           val referencedentities = referencedEntities(request)
 
+          // To avoid using same entity name with action
+          val latestDocId = WhiskActionVersionList.get(entityName, entityStore).map { result =>
+            result.matchedDocId(None).getOrElse(entityName.toDocId)
+          }
+
           onComplete(entitlementProvider.check(user, Privilege.READ, referencedentities)) {
             case Success(_) =>
-              putEntity(
-                WhiskPackage,
-                entityStore,
-                entityName.toDocId,
-                overwrite,
-                update(request) _,
-                () => create(request, entityName))
+              onComplete(latestDocId) {
+                case Success(docId) =>
+                  putEntity(
+                    WhiskPackage,
+                    entityStore,
+                    docId,
+                    overwrite,
+                    update(request) _,
+                    () => create(request, entityName))
+                case Failure(f) =>
+                  terminate(InternalServerError)
+              }
             case Failure(f) =>
               rewriteEntitlementFailure(f)
           }
@@ -149,14 +159,15 @@ trait WhiskPackagesApi extends WhiskCollectionAPI with ReferencedEntities {
               case Right(list) if list.nonEmpty && force =>
                 Future sequence {
                   list.map(action => {
-                    WhiskAction.get(
-                      entityStore,
-                      wp.fullyQualifiedName(false)
-                        .add(action.fullyQualifiedName(false).name)
-                        .toDocId) flatMap { actionWithRevision =>
+                    WhiskAction.get(entityStore, action.docid) flatMap { actionWithRevision =>
                       WhiskAction.del(entityStore, actionWithRevision.docinfo)
                     }
                   })
+                } andThen {
+                  case _ =>
+                    list.foreach { action =>
+                      WhiskActionVersionList.deleteCache(action.fullyQualifiedName(false))
+                    }
                 } flatMap { _ =>
                   Future.successful({})
                 }

core/controller/src/main/scala/org/apache/openwhisk/core/entitlement/PackageCollection.scala

@@ -62,8 +62,11 @@ class PackageCollection(entityStore: EntityStore)(implicit logging: Logging) ext
         case Privilege.READ =>
           // must determine if this is a public or owned package
           // or, for a binding, that it references a public or owned package
-          val docid = FullyQualifiedEntityName(resource.namespace.root.toPath, EntityName(pkgname)).toDocId
-          checkPackageReadPermission(namespaces, isOwner, docid)
+          val entityName = FullyQualifiedEntityName(resource.namespace.root.toPath, EntityName(pkgname))
+          WhiskActionVersionList.get(entityName, entityStore).flatMap { result =>
+            val docid = result.matchedDocId(None).getOrElse(entityName.toDocId)
+            checkPackageReadPermission(namespaces, isOwner, docid)
+          }
         case _ => Future.successful(isOwner && allowedEntityRights.contains(right))
       }
     } getOrElse {

tests/src/test/scala/org/apache/openwhisk/core/controller/test/EntitlementProviderTests.scala

@@ -335,15 +335,15 @@ class EntitlementProviderTests extends ControllerTestCommon with ScalaFutures {
       (REJECT, guestUser, Right(false)))
 
     // this forces a doc mismatch error
-    val trigger = WhiskTrigger(someUser.namespace.name.toPath, MakeName.next())
-    put(entityStore, trigger)
+    val action = WhiskAction(someUser.namespace.name.toPath, MakeName.next(), jsDefault(""))
+    put(entityStore, action)
     paths foreach {
       case (priv, who, expected) =>
         val check = new PackageCollection(entityStore).implicitRights(
           who,
           Set(who.namespace.name.asString),
           priv,
-          Resource(someUser.namespace.name.toPath, PACKAGES, Some(trigger.name.asString)))
+          Resource(someUser.namespace.name.toPath, PACKAGES, Some(action.name.asString)))
         Await.ready(check, requestTimeout).eitherValue.get shouldBe expected
     }
   }

tests/src/test/scala/org/apache/openwhisk/core/controller/test/PackagesApiTests.scala

@@ -862,11 +862,11 @@ class PackagesApiTests extends ControllerTestCommon with WhiskPackagesApi {
 
   it should "reject bind to non-package" in {
     implicit val tid = transid()
-    val trigger = WhiskTrigger(namespace, aname())
-    val reference = WhiskPackage(namespace, aname(), Some(Binding(trigger.namespace.root, trigger.name)))
+    val action = WhiskAction(namespace, aname(), jsDefault("??"))
+    val reference = WhiskPackage(namespace, aname(), Some(Binding(action.namespace.root, action.name)))
     val content = WhiskPackagePut(reference.binding)
 
-    put(entityStore, trigger)
+    put(entityStore, action)
 
     Put(s"$collectionPath/${reference.name}", content) ~> Route.seal(routes(creds)) ~> check {
       status should be(Conflict)