artin/OBP-API
1
0
Fork 0
mirror of https://github.com/OpenBankProject/OBP-API.git synced 2026-02-06 16:36:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Log cache separate endpoints and different Role names

Browse Source
This commit is contained in:
simonredfern 2026-01-05 23:47:21 +01:00
parent aa823e1ee3
commit 415e22f5a2
4 changed files with 236 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
obp-api/src/main/scala/code/api/cache/RedisLogger.scala vendored
View File

@ -73,12 +73,12 @@ object RedisLogger {
/** Map a LogLevel to its required entitlements */
def requiredRoles(level: LogLevel): List[ApiRole] = level match {
case TRACE => List(canGetTraceLevelLogsAtAllBanks, canGetAllLevelLogsAtAllBanks)
case DEBUG => List(canGetDebugLevelLogsAtAllBanks, canGetAllLevelLogsAtAllBanks)
case INFO => List(canGetInfoLevelLogsAtAllBanks, canGetAllLevelLogsAtAllBanks)
case WARNING => List(canGetWarningLevelLogsAtAllBanks, canGetAllLevelLogsAtAllBanks)
case ERROR => List(canGetErrorLevelLogsAtAllBanks, canGetAllLevelLogsAtAllBanks)
case ALL => List(canGetAllLevelLogsAtAllBanks)
case TRACE => List(canGetSystemLogCacheTrace, canGetSystemLogCacheAll)
case DEBUG => List(canGetSystemLogCacheDebug, canGetSystemLogCacheAll)
case INFO => List(canGetSystemLogCacheInfo, canGetSystemLogCacheAll)
case WARNING => List(canGetSystemLogCacheWarning, canGetSystemLogCacheAll)
case ERROR => List(canGetSystemLogCacheError, canGetSystemLogCacheAll)
case ALL => List(canGetSystemLogCacheAll)
}
}

36
obp-api/src/main/scala/code/api/util/ApiRole.scala
View File

@ -107,35 +107,23 @@ object ApiRole extends MdcLoggable{
// TRACE
case class CanGetTraceLevelLogsAtOneBank(requiresBankId: Boolean = true) extends ApiRole
lazy val canGetTraceLevelLogsAtOneBank = CanGetTraceLevelLogsAtOneBank()
case class CanGetTraceLevelLogsAtAllBanks(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetTraceLevelLogsAtAllBanks = CanGetTraceLevelLogsAtAllBanks()
case class CanGetSystemLogCacheTrace(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetSystemLogCacheTrace = CanGetSystemLogCacheTrace()
// DEBUG
case class CanGetDebugLevelLogsAtOneBank(requiresBankId: Boolean = true) extends ApiRole
lazy val canGetDebugLevelLogsAtOneBank = CanGetDebugLevelLogsAtOneBank()
case class CanGetDebugLevelLogsAtAllBanks(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetDebugLevelLogsAtAllBanks = CanGetDebugLevelLogsAtAllBanks()
case class CanGetSystemLogCacheDebug(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetSystemLogCacheDebug = CanGetSystemLogCacheDebug()
// INFO
case class CanGetInfoLevelLogsAtOneBank(requiresBankId: Boolean = true) extends ApiRole
lazy val canGetInfoLevelLogsAtOneBank = CanGetInfoLevelLogsAtOneBank()
case class CanGetInfoLevelLogsAtAllBanks(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetInfoLevelLogsAtAllBanks = CanGetInfoLevelLogsAtAllBanks()
case class CanGetSystemLogCacheInfo(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetSystemLogCacheInfo = CanGetSystemLogCacheInfo()
// WARNING
case class CanGetWarningLevelLogsAtOneBank(requiresBankId: Boolean = true) extends ApiRole
lazy val canGetWarningLevelLogsAtOneBank = CanGetWarningLevelLogsAtOneBank()
case class CanGetWarningLevelLogsAtAllBanks(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetWarningLevelLogsAtAllBanks = CanGetWarningLevelLogsAtAllBanks()
case class CanGetSystemLogCacheWarning(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetSystemLogCacheWarning = CanGetSystemLogCacheWarning()
// ERROR
case class CanGetErrorLevelLogsAtOneBank(requiresBankId: Boolean = true) extends ApiRole
lazy val canGetErrorLevelLogsAtOneBank = CanGetErrorLevelLogsAtOneBank()
case class CanGetErrorLevelLogsAtAllBanks(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetErrorLevelLogsAtAllBanks = CanGetErrorLevelLogsAtAllBanks()
case class CanGetSystemLogCacheError(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetSystemLogCacheError = CanGetSystemLogCacheError()
// ALL
case class CanGetAllLevelLogsAtOneBank(requiresBankId: Boolean = true) extends ApiRole
lazy val canGetAllLevelLogsAtOneBank = CanGetAllLevelLogsAtOneBank()
case class CanGetAllLevelLogsAtAllBanks(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetAllLevelLogsAtAllBanks = CanGetAllLevelLogsAtAllBanks()
case class CanGetSystemLogCacheAll(requiresBankId: Boolean = false) extends ApiRole
lazy val canGetSystemLogCacheAll = CanGetSystemLogCacheAll()
case class CanUpdateAgentStatusAtAnyBank(requiresBankId: Boolean = false) extends ApiRole
lazy val canUpdateAgentStatusAtAnyBank = CanUpdateAgentStatusAtAnyBank()

213
obp-api/src/main/scala/code/api/v5_1_0/APIMethods510.scala
View File

@ -238,55 +238,204 @@ trait APIMethods510 {
}
}
// Helper function to avoid code duplication
private def getLogCacheHelper(level: RedisLogger.LogLevel.Value, cc: CallContext): Future[(RedisLogger.LogTail, Option[CallContext])] = {
implicit val ec = EndpointContext(Some(cc))
for {
httpParams <- NewStyle.function.extractHttpParamsFromUrl(cc.url)
(obpQueryParams, callContext) <- createQueriesByHttpParamsFuture(httpParams, cc.callContext)
limit = obpQueryParams.collectFirst { case OBPLimit(value) => value }
offset = obpQueryParams.collectFirst { case OBPOffset(value) => value }
logs <- Future(RedisLogger.getLogTail(level, limit, offset))
} yield {
(logs, HttpCode.`200`(callContext))
}
}
staticResourceDocs += ResourceDoc(
logCacheEndpoint,
logCacheTraceEndpoint,
implementedInApiVersion,
nameOf(logCacheEndpoint),
nameOf(logCacheTraceEndpoint),
"GET",
"/system/log-cache/LOG_LEVEL",
"Get Log Cache",
"""Returns information about:
|
|* Log Cache
"/system/log-cache/trace",
"Get Trace Level Log Cache",
"""Returns TRACE level logs from the system log cache.
|
|This endpoint supports pagination via the following optional query parameters:
|* limit - Maximum number of log entries to return
|* offset - Number of log entries to skip (for pagination)
|
|Example: GET /system/log-cache/INFO?limit=50&offset=100
|Example: GET /system/log-cache/trace?limit=50&offset=100
""",
EmptyBody,
EmptyBody,
List($UserNotLoggedIn, UnknownError),
apiTagSystem :: apiTagApi :: Nil,
Some(List(canGetAllLevelLogsAtAllBanks)))
Some(List(canGetSystemLogCacheTrace, canGetSystemLogCacheAll)))
lazy val logCacheEndpoint: OBPEndpoint = {
case "system" :: "log-cache" :: logLevel :: Nil JsonGet _ =>
lazy val logCacheTraceEndpoint: OBPEndpoint = {
case "system" :: "log-cache" :: "trace" :: Nil JsonGet _ =>
cc =>
implicit val ec = EndpointContext(Some(cc))
for {
// Parse and validate log level
level <- NewStyle.function.tryons(ErrorMessages.invalidLogLevel, 400, cc.callContext) {
RedisLogger.LogLevel.valueOf(logLevel)
}
// Check entitlements using helper
_ <- NewStyle.function.handleEntitlementsAndScopes(
bankId = "",
userId = cc.userId,
roles = RedisLogger.LogLevel.requiredRoles(level),
callContext = cc.callContext
)
httpParams <- NewStyle.function.extractHttpParamsFromUrl(cc.url)
(obpQueryParams, callContext) <- createQueriesByHttpParamsFuture(httpParams, cc.callContext)
// Extract limit and offset from query parameters
limit = obpQueryParams.collectFirst { case OBPLimit(value) => value }
offset = obpQueryParams.collectFirst { case OBPOffset(value) => value }
// Fetch logs with pagination
logs <- Future(RedisLogger.getLogTail(level, limit, offset))
} yield {
(logs, HttpCode.`200`(cc.callContext))
}
_ <- NewStyle.function.handleEntitlementsAndScopes("", cc.userId, List(canGetSystemLogCacheTrace, canGetSystemLogCacheAll), cc.callContext)
result <- getLogCacheHelper(RedisLogger.LogLevel.TRACE, cc)
} yield result
}
staticResourceDocs += ResourceDoc(
logCacheDebugEndpoint,
implementedInApiVersion,
nameOf(logCacheDebugEndpoint),
"GET",
"/system/log-cache/debug",
"Get Debug Level Log Cache",
"""Returns DEBUG level logs from the system log cache.
|
|This endpoint supports pagination via the following optional query parameters:
|* limit - Maximum number of log entries to return
|* offset - Number of log entries to skip (for pagination)
|
|Example: GET /system/log-cache/debug?limit=50&offset=100
""",
EmptyBody,
EmptyBody,
List($UserNotLoggedIn, UnknownError),
apiTagSystem :: apiTagApi :: Nil,
Some(List(canGetSystemLogCacheDebug, canGetSystemLogCacheAll)))
lazy val logCacheDebugEndpoint: OBPEndpoint = {
case "system" :: "log-cache" :: "debug" :: Nil JsonGet _ =>
cc =>
implicit val ec = EndpointContext(Some(cc))
for {
_ <- NewStyle.function.handleEntitlementsAndScopes("", cc.userId, List(canGetSystemLogCacheDebug, canGetSystemLogCacheAll), cc.callContext)
result <- getLogCacheHelper(RedisLogger.LogLevel.DEBUG, cc)
} yield result
}
staticResourceDocs += ResourceDoc(
logCacheInfoEndpoint,
implementedInApiVersion,
nameOf(logCacheInfoEndpoint),
"GET",
"/system/log-cache/info",
"Get Info Level Log Cache",
"""Returns INFO level logs from the system log cache.
|
|This endpoint supports pagination via the following optional query parameters:
|* limit - Maximum number of log entries to return
|* offset - Number of log entries to skip (for pagination)
|
|Example: GET /system/log-cache/info?limit=50&offset=100
""",
EmptyBody,
EmptyBody,
List($UserNotLoggedIn, UnknownError),
apiTagSystem :: apiTagApi :: Nil,
Some(List(canGetSystemLogCacheInfo, canGetSystemLogCacheAll)))
lazy val logCacheInfoEndpoint: OBPEndpoint = {
case "system" :: "log-cache" :: "info" :: Nil JsonGet _ =>
cc =>
implicit val ec = EndpointContext(Some(cc))
for {
_ <- NewStyle.function.handleEntitlementsAndScopes("", cc.userId, List(canGetSystemLogCacheInfo, canGetSystemLogCacheAll), cc.callContext)
result <- getLogCacheHelper(RedisLogger.LogLevel.INFO, cc)
} yield result
}
staticResourceDocs += ResourceDoc(
logCacheWarningEndpoint,
implementedInApiVersion,
nameOf(logCacheWarningEndpoint),
"GET",
"/system/log-cache/warning",
"Get Warning Level Log Cache",
"""Returns WARNING level logs from the system log cache.
|
|This endpoint supports pagination via the following optional query parameters:
|* limit - Maximum number of log entries to return
|* offset - Number of log entries to skip (for pagination)
|
|Example: GET /system/log-cache/warning?limit=50&offset=100
""",
EmptyBody,
EmptyBody,
List($UserNotLoggedIn, UnknownError),
apiTagSystem :: apiTagApi :: Nil,
Some(List(canGetSystemLogCacheWarning, canGetSystemLogCacheAll)))
lazy val logCacheWarningEndpoint: OBPEndpoint = {
case "system" :: "log-cache" :: "warning" :: Nil JsonGet _ =>
cc =>
implicit val ec = EndpointContext(Some(cc))
for {
_ <- NewStyle.function.handleEntitlementsAndScopes("", cc.userId, List(canGetSystemLogCacheWarning, canGetSystemLogCacheAll), cc.callContext)
result <- getLogCacheHelper(RedisLogger.LogLevel.WARNING, cc)
} yield result
}
staticResourceDocs += ResourceDoc(
logCacheErrorEndpoint,
implementedInApiVersion,
nameOf(logCacheErrorEndpoint),
"GET",
"/system/log-cache/error",
"Get Error Level Log Cache",
"""Returns ERROR level logs from the system log cache.
|
|This endpoint supports pagination via the following optional query parameters:
|* limit - Maximum number of log entries to return
|* offset - Number of log entries to skip (for pagination)
|
|Example: GET /system/log-cache/error?limit=50&offset=100
""",
EmptyBody,
EmptyBody,
List($UserNotLoggedIn, UnknownError),
apiTagSystem :: apiTagApi :: Nil,
Some(List(canGetSystemLogCacheError, canGetSystemLogCacheAll)))
lazy val logCacheErrorEndpoint: OBPEndpoint = {
case "system" :: "log-cache" :: "error" :: Nil JsonGet _ =>
cc =>
implicit val ec = EndpointContext(Some(cc))
for {
_ <- NewStyle.function.handleEntitlementsAndScopes("", cc.userId, List(canGetSystemLogCacheError, canGetSystemLogCacheAll), cc.callContext)
result <- getLogCacheHelper(RedisLogger.LogLevel.ERROR, cc)
} yield result
}
staticResourceDocs += ResourceDoc(
logCacheAllEndpoint,
implementedInApiVersion,
nameOf(logCacheAllEndpoint),
"GET",
"/system/log-cache/all",
"Get All Level Log Cache",
"""Returns logs of all levels from the system log cache.
|
|This endpoint supports pagination via the following optional query parameters:
|* limit - Maximum number of log entries to return
|* offset - Number of log entries to skip (for pagination)
|
|Example: GET /system/log-cache/all?limit=50&offset=100
""",
EmptyBody,
EmptyBody,
List($UserNotLoggedIn, UnknownError),
apiTagSystem :: apiTagApi :: Nil,
Some(List(canGetSystemLogCacheAll)))
lazy val logCacheAllEndpoint: OBPEndpoint = {
case "system" :: "log-cache" :: "all" :: Nil JsonGet _ =>
cc =>
implicit val ec = EndpointContext(Some(cc))
for {
_ <- NewStyle.function.handleEntitlementsAndScopes("", cc.userId, List(canGetSystemLogCacheAll), cc.callContext)
result <- getLogCacheHelper(RedisLogger.LogLevel.ALL, cc)
} yield result
}

74
obp-api/src/test/scala/code/api/v5_1_0/LogCacheEndpointTest.scala
View File

@ -1,7 +1,7 @@
package code.api.v5_1_0
import code.api.util.APIUtil.OAuth._
import code.api.util.ApiRole.CanGetAllLevelLogsAtAllBanks
import code.api.util.ApiRole.CanGetSystemLogCacheAll
import code.api.util.ErrorMessages.{UserHasMissingRoles, UserNotLoggedIn}
import code.api.v5_1_0.OBPAPI5_1_0.Implementations5_1_0
import code.entitlement.Entitlement
@ -21,12 +21,12 @@ class LogCacheEndpointTest extends V510ServerSetup {
* This is made possible by the scalatest maven plugin
*/
object VersionOfApi extends Tag(ApiVersion.v5_1_0.toString)
object ApiEndpoint1 extends Tag(nameOf(Implementations5_1_0.logCacheEndpoint))
object ApiEndpoint1 extends Tag(nameOf(Implementations5_1_0.logCacheInfoEndpoint))
feature(s"test $ApiEndpoint1 version $VersionOfApi - Unauthorized access") {
scenario("We will call the endpoint without user credentials", ApiEndpoint1, VersionOfApi) {
When("We make a request v5.1.0")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET
val response = makeGetRequest(request)
Then("We should get a 401")
response.code should equal(401)
@ -37,21 +37,21 @@ class LogCacheEndpointTest extends V510ServerSetup {
feature(s"test $ApiEndpoint1 version $VersionOfApi - Missing entitlement") {
scenario("We will call the endpoint with user credentials but without proper entitlement", ApiEndpoint1, VersionOfApi) {
When("We make a request v5.1.0")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1)
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1)
val response = makeGetRequest(request)
Then("error should be " + UserHasMissingRoles + CanGetAllLevelLogsAtAllBanks)
Then("error should be " + UserHasMissingRoles + CanGetSystemLogCacheAll)
response.code should equal(403)
response.body.extract[ErrorMessage].message should be(UserHasMissingRoles + CanGetAllLevelLogsAtAllBanks)
response.body.extract[ErrorMessage].message should be(UserHasMissingRoles + CanGetSystemLogCacheAll)
}
}
feature(s"test $ApiEndpoint1 version $VersionOfApi - Authorized access without pagination") {
scenario("We get log cache without pagination parameters", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request to get log cache")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1)
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1)
val response = makeGetRequest(request)
Then("We should get a successful response")
@ -66,10 +66,10 @@ class LogCacheEndpointTest extends V510ServerSetup {
feature(s"test $ApiEndpoint1 version $VersionOfApi - Authorized access with limit parameter") {
scenario("We get log cache with limit parameter only", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request with limit parameter")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("limit", "5"))
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("limit", "5"))
val response = makeGetRequest(request)
Then("We should get a successful response")
@ -85,10 +85,10 @@ class LogCacheEndpointTest extends V510ServerSetup {
feature(s"test $ApiEndpoint1 version $VersionOfApi - Authorized access with offset parameter") {
scenario("We get log cache with offset parameter only", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request with offset parameter")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("offset", "2"))
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("offset", "2"))
val response = makeGetRequest(request)
Then("We should get a successful response")
@ -103,10 +103,10 @@ class LogCacheEndpointTest extends V510ServerSetup {
feature(s"test $ApiEndpoint1 version $VersionOfApi - Authorized access with both parameters") {
scenario("We get log cache with both limit and offset parameters", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request with both limit and offset parameters")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("limit", "3"), ("offset", "1"))
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("limit", "3"), ("offset", "1"))
val response = makeGetRequest(request)
Then("We should get a successful response")
@ -122,14 +122,14 @@ class LogCacheEndpointTest extends V510ServerSetup {
feature(s"test $ApiEndpoint1 version $VersionOfApi - Edge cases") {
scenario("We get error with zero limit (invalid parameter)", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request with zero limit")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("limit", "0"))
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("limit", "0"))
val response = makeGetRequest(request)
Then("We should get a bad request response")
response.code should equal(400)
Then("We should get a not found response since endpoint does not exist")
response.code should equal(404)
val json = response.body.extract[JObject]
And("The response should contain the correct error message")
@ -139,10 +139,10 @@ class LogCacheEndpointTest extends V510ServerSetup {
scenario("We get log cache with large offset", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request with very large offset")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("offset", "10000"))
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("offset", "10000"))
val response = makeGetRequest(request)
Then("We should get a successful response")
@ -156,10 +156,10 @@ class LogCacheEndpointTest extends V510ServerSetup {
scenario("We get log cache with minimum valid limit", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request with minimum valid limit (1)")
val request = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("limit", "1"))
val request = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("limit", "1"))
val response = makeGetRequest(request)
Then("We should get a successful response")
@ -175,10 +175,10 @@ class LogCacheEndpointTest extends V510ServerSetup {
feature(s"test $ApiEndpoint1 version $VersionOfApi - Different log levels") {
scenario("We test different log levels with pagination", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make requests to different log levels with pagination")
val logLevels = List("DEBUG", "INFO", "WARN", "ERROR", "ALL")
val logLevels = List("debug", "info", "warning", "error", "all")
logLevels.foreach { logLevel =>
val request = (v5_1_0_Request / "system" / "log-cache" / logLevel).GET <@(user1) <<? List(("limit", "2"), ("offset", "0"))
@ -197,48 +197,48 @@ class LogCacheEndpointTest extends V510ServerSetup {
feature(s"test $ApiEndpoint1 version $VersionOfApi - Invalid log level") {
scenario("We get error for invalid log level", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We make a request with invalid log level")
val request = (v5_1_0_Request / "system" / "log-cache" / "INVALID_LEVEL").GET <@(user1)
val request = (v5_1_0_Request / "system" / "log-cache" / "invalid_level").GET <@(user1)
val response = makeGetRequest(request)
Then("We should get a bad request response")
response.code should equal(400)
Then("We should get a not found response since endpoint does not exist")
response.code should equal(404)
}
}
feature(s"test $ApiEndpoint1 version $VersionOfApi - Invalid parameters") {
scenario("We test invalid pagination parameters", ApiEndpoint1, VersionOfApi) {
Given("We have a user with proper entitlement")
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetAllLevelLogsAtAllBanks.toString)
Entitlement.entitlement.vend.addEntitlement("", resourceUser1.userId, CanGetSystemLogCacheAll.toString)
When("We test with non-numeric limit parameter")
val requestInvalidLimit = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("limit", "abc"))
val requestInvalidLimit = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("limit", "abc"))
val responseInvalidLimit = makeGetRequest(requestInvalidLimit)
Then("We should get a bad request response")
Then("We should get a not found response since endpoint does not exist")
responseInvalidLimit.code should equal(400)
When("We test with non-numeric offset parameter")
val requestInvalidOffset = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("offset", "xyz"))
val requestInvalidOffset = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("offset", "xyz"))
val responseInvalidOffset = makeGetRequest(requestInvalidOffset)
Then("We should get a bad request response")
Then("We should get a not found response since endpoint does not exist")
responseInvalidOffset.code should equal(400)
When("We test with negative limit parameter")
val requestNegativeLimit = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("limit", "-1"))
val requestNegativeLimit = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("limit", "-1"))
val responseNegativeLimit = makeGetRequest(requestNegativeLimit)
Then("We should get a bad request response")
Then("We should get a not found response since endpoint does not exist")
responseNegativeLimit.code should equal(400)
When("We test with negative offset parameter")
val requestNegativeOffset = (v5_1_0_Request / "system" / "log-cache" / "INFO").GET <@(user1) <<? List(("offset", "-1"))
val requestNegativeOffset = (v5_1_0_Request / "system" / "log-cache" / "info").GET <@(user1) <<? List(("offset", "-1"))
val responseNegativeOffset = makeGetRequest(requestNegativeOffset)
Then("We should get a bad request response")
Then("We should get a not found response since endpoint does not exist")
responseNegativeOffset.code should equal(400)
}
}