coldbox

coldbox

Skills by this owner — View all

Showing 121 skills

Use this skill when rendering views and partials in ColdBox, creating reusable view components, caching view output, passing data to views, rendering views from services, using renderView() inline, or dynamically selecting views based on context.

Use this skill when writing xUnit-style tests in TestBox using test functions (testXxx()), setup/teardown lifecycle (beforeTests/afterTests/setup/teardown), the $assert assertion object, grouped assertions with $assert.all() / assertAll(), retrying flaky tests with the retries method or bundle annotation, attaching files with attach(), skipping a single test or an entire test class with the class-level skip annotation, engine detection helpers (isBoxLang/isLucee/isAdobe), or the Arrange-Act-Assert (AAA) pattern for unit testing services, models, and utilities in isolation.

Use this skill when writing browser tests for a ColdBox application with coldbox.system.testing.BrowserTestCase (BoxLang + bx-playwright): choosing browser tests vs BaseTestCase integration tests, browse() with isolated pages, the baseURL and browserProfile annotations, this.playwright(), browserAvailable() and browserUnavailableReason(), the named route helpers routeURL(), visitRoute() and assertRouteIs() (with or without params, name@module and module:name routes), logging users in and out with loginAs() and logout() through the test-only BrowserTesting core module (moduleSettings.browserTesting enabled/token/login/logout, X-Browser-Testing-Token header, testing environment only, 404 otherwise), running the app server for the browser (CommandBox server or TestBox --web-server), and CI setup.

Use this skill to understand which ColdBox testing base class to extend for a given test type, configure test bundle annotations (appMapping, configMapping, unloadColdBox, loadColdBox, coldboxAppKey), set up the tests/ harness (Application.cfc, folder structure), or choose between integration testing (BaseTestCase), isolated handler testing (BaseHandlerTest), model unit testing (BaseModelTest), interceptor unit testing (BaseInterceptorTest), and real-browser testing of the running app (BrowserTestCase, BoxLang + bx-playwright).

Use this skill when running TestBox tests: CommandBox CLI (testbox run), BoxLang CLI (./testbox/run), HTML web runner, programmatic TestBox instantiation (run/runRaw/runRemote), configuring test directories or bundles, using the streaming runner (--stream flag / StreamingRunner), watcher mode, all CLI flags (--show-failed-only, --dry-run, --slow-threshold-ms, --stacktrace, --max-failures), toggling code coverage with the coverageEnabled URL parameter (opt-in since TestBox 7.1), retrying failing specs (--retries), rerunning only the last failures (--failed), starting a web server for browser tests (--web-server, --web-server-url, --web-server-timeout), or setting up box.json testbox configuration.

Use this skill when selecting or configuring TestBox reporters: Agent, ANTJunit, Console, Doc, JSON, JUnit, Min, MinText, Simple, Text, XML, Streaming; setting reporter options (hideSkipped, editor links for Simple reporter); how reporters show spec attachments (attach(), browser screenshots/traces/videos) and retry attempts; or creating a custom reporter by implementing the IReporter interface.

Use this skill when writing fluent expectations in TestBox using expect(), the collection modes (expectAll, expectAny, expectSome, expectNone), expectation context with withContext(), and the built-in matchers: toBe, toBeTrue, toBeFalse, toBeTruthy, toBeFalsy, toBeNull, toBeArray, toBeStruct, toBeEmpty, toHaveLength, toHaveSize, toBeTypeOf, toBeInstanceOf, toBeSameInstanceAs, toHaveKey, toHaveDeepKey, toInclude, toIncludeWithCase, toIncludeAll, toIncludeAny, toIncludeNone, toMatch, toBeGT, toBeGTE, toBeLT, toBeLTE, toBeBetween, toBeCloseTo, toSatisfy, toThrow, toThrowMatching; the BoxLang-only Set matchers (toBeASet, toEqualSet, toBeSubsetOf, toBeSupersetOf, toBeDisjointFrom, toHaveUnion, toHaveIntersection, toHaveDifference, toHaveSymmetricDifference); the BoxLang-only Range matchers (toBeRange, toContainValue, toContainRange, toBeInRange, toBeBeforeRange, toBeAfterRange, toBeBounded, toBeUnbounded, toBeHalfBounded, toBeIterable, toBeAscending, toBeDescending, toHaveStep, toClampTo); the BoxLang-only Data Navigator matchers (toHavePath, toHavePathValue, toHavePathType, toHavePathSatisfying, path, queryPath); the BoxLang-only browser matchers for bx-playwright pages and locators (toHaveTitle, toHaveURL, toSee, toHaveText, toBeVisible, toBeHidden, toHaveCount, toHaveValue; see testbox-browser-testing); the not operator (notToBe, notToBeEmpty, etc.); chaining matchers on one expect(); or creating custom matchers with addMatchers().

Use this skill when writing or running browser tests with TestBox on BoxLang: extending testbox.system.BrowserSpec, installing bx-playwright and Chromium (install-bx-module bx-playwright, bxPlaywright install), the browserProfile and baseURL class annotations, browse() with one isolated page per callback argument, this.playwright() and browserAvailable(), the browser matchers (toHaveTitle, toHaveURL, toHavePath, toSee, toHaveText, toBeVisible, toBeHidden, toHaveCount, toHaveValue and their not forms), automatic screenshot/trace/video attachments, attach(), spec retries (it retries argument, retries bundle or method annotation, --retries), rerunning failures with --failed, starting the app with --web-server/--web-server-url/--web-server-timeout, CI setup, and debugging failed browser specs with bxPlaywright show-trace.

Use this skill when writing BDD-style tests with TestBox using describe/it blocks, feature/story/scenario/given/when/then Gherkin-style suites, lifecycle hooks (beforeAll/afterAll/beforeEach/afterEach/aroundEach), focused specs (fit/fdescribe), skipping specs (xit/xdescribe/skip()) or whole test classes with the class-level skip annotation, engine detection helpers (isBoxLang/isLucee/isAdobe), grouped assertions with assertAll(), collection expectations (expectAll/expectAny/expectSome/expectNone), spec data binding, retrying flaky specs (it/fit/xit retries argument, retries bundle annotation), attaching files to a spec with attach(), asyncAll parallel specs, nested suite trees, labels, or organizing tests around behavior descriptions.

Use this skill when building RESTful APIs in ColdBox using RestHandler, creating CRUD API endpoints, implementing API versioning, handling JWT/bearer token authentication, building structured error responses, using the Response object's fluent builders (setData() message/location, withETag(), withCacheControl()), adding HTTP caching to responses, or creating resource representations with mementos.

Use this skill when creating ColdBox interceptors for cross-cutting concerns, listening to framework lifecycle events, implementing security checks, logging, CORS, rate limiting, request/response transformation, firing and listening to custom interception points, or detecting whether announce() was short-circuited by a listener.

Use this skill when configuring a ColdBox application in ColdBox.cfc, setting up environments, managing module settings, defining datasources, configuring logging with LogBox, setting up caching with CacheBox, or wiring dependencies with WireBox settings.

Use this skill when implementing caching inside a ColdBox application -- configuring CacheBox via ColdBox.cfc or config/CacheBox.cfc, injecting caches with WireBox (cachebox:name), using getCache() in handlers, event output caching with action cache annotations (including etag/etagWeak/lastModified/cacheControl auto-computed HTTP caching), route-level cache rules with Router.withCache(), view fragment caching with renderView(cache=true), query caching, cache listeners as ColdBox interceptors, engine-native providers (BoxLangColdBoxProvider, LuceeColdBoxProvider, CFColdBoxProvider), Redis/distributed provider setup, or choosing between default and template caches.

Use this skill when working with the ColdBox event object (prc/rc), managing request collections, rendering views and data responses, handling redirects with relocate(), controlling HTTP status codes, or implementing event caching in ColdBox handlers.

Use this skill when creating reusable ColdBox modules, writing ModuleConfig.cfc, defining module-specific routes, models, settings, and interceptors, packaging modules for ForgeBox, or building internal application sub-systems as modules.

Use this skill when working with the ColdBox RequestContext object (event), managing rc and prc collections, building URLs with buildLink(), detecting HTTP methods, reading the original un-spoofed HTTP verb with getOriginalHTTPMethod(), setting HTTP caching primitives (etag/lastModified/cacheControl), accessing request metadata, working with flash scope, handling AJAX requests, or reading HTTP headers and body content.

Use this skill when integrating AI capabilities into a ColdBox application using the BoxLang AI library (bx-ai module) -- including simple chat, streaming (see coldbox-sse-streaming for first-class SSE), pipelines, agents, RAG with vector memory, document loading, tool calling, auto-scaffolding a REST API for an IAiRunnable with route( ... ).toAi(), exposing an AI Gateway over HTTP with route( ... ).toAiGateway() for platform webhooks and human-in-the-loop approvals, and injecting the AI service into handlers or models.

Use this skill when configuring ColdBox routes, setting up RESTful resource routes, creating route groups, implementing URL pattern matching with constraints, defining named routes, answering a route inline with a toResponse() closure, attaching route-scoped middleware with .middleware()/middlewareGroup()/.withoutMiddleware(), declaring route-level cache rules with Router.withCache(), streaming a route with Router.toSSE(), exposing BoxLang AI surfaces with the toAi(), toMCP() and toAiGateway() route terminators, or working with Router.cfc in a ColdBox application.

Use this skill when creating ColdBox scheduled tasks, building Scheduler.cfc files, registering task frequencies, preventing overlapping runs with withNoOverlaps(), constraining tasks to a time-of-day window with between()/startOnTime()/endOnTime(), managing task life-cycles (before/after/onFailure/onSuccess), checking scheduler state via started/startedAt, using server fixation for clustered apps, or configuring module schedulers.

Use this skill when streaming Server-Sent Events (SSE) from a ColdBox handler or route with event.sse(), building a route that always streams with Router.toSSE(), sending data/events/errors through an SSEEmitter, reacting to SSE connect/disconnect/error via the preSSEConnection/postSSEConnection/onSSEError interception points, or configuring the this.sse settings block (keep-alive interval, reconnect hints, CORS defaults).

Use this skill when testing ColdBox event handlers with execute(), asserting rc/prc collections, verifying view selection and rendered output, mocking relocations, mocking the incoming request body with execute()'s body argument, testing renderData() and getHandlerResults(), setting HTTP methods and headers, injecting mocks into handlers, or using BaseHandlerTest for isolated handler unit tests.

Use this skill when using the TestBox $assert object for xUnit-style assertions: isTrue, isFalse, isTruthy, isFalsy, isEqual, isSameInstance, includes, includesAll, includesAny, includesNone, isEmpty, key, deepKey, instanceOf, throws, between, closeTo, lengthOf, match, null, typeOf, isJSON and others; grouping assertions with $assert.all() / assertAll() so every failure is reported at once; registering custom assertion functions with addAssertions(); or using BoxLang dynamic assertion methods (assertIsTrue, assertBetween, etc.).

Use this skill when implementing JWT (JSON Web Token) authentication in ColdBox REST APIs with CBSecurity, generating access/refresh tokens, validating bearer tokens, configuring JWT settings and secret keys, implementing token refresh endpoints, or securing API routes with JWT authentication middleware.

Use this skill when implementing authorization in ColdBox with CBSecurity, defining security rules for events and URLs, checking user roles with cbsecurity.has(), checking permissions with cbsecurity.can(), implementing role-based route protection, using @secured annotations on handler actions, or blocking unauthorized access.