Results for “integration”

.NET advanced testing skills overview and navigation center. Triggered when users ask about "integration testing", "API testing", "containerized testing", "microservice testing", "test framework migration", "Testcontainers", "Aspire testing", and other advanced testing needs. Recommends appropriate sub-skills based on specific requirements, covering integration testing, Testcontainers, Aspire testing, framework upgrades, and other 8 advanced skills. Keywords: integration testing, integration testing, API testing, advanced testing, advanced testing, testcontainers, aspire testing, WebApplicationFactory, TestServer, database test, database testing, EF Core test, MongoDB test, Redis test, Docker test, container testing, microservice test, microservice testing, .NET Aspire, xUnit upgrade, TUnit, framework migration

The English summary is being prepared. Showing the original description.

Complete guide for Testcontainers NoSQL integration testing. Use when containerized integration testing for MongoDB or Redis. Covers MongoDB document operations, Redis five data structures, Collection Fixture pattern. Includes BSON serialization, index performance testing, data isolation strategy, and container lifecycle management. Keywords: testcontainers mongodb, testcontainers redis, mongodb integration test, redis integration test, nosql testing, MongoDbContainer, RedisContainer, IMongoDatabase, IConnectionMultiplexer, BSON serialization, BsonDocument, document model testing, cache testing, Collection Fixture

The English summary is being prepared. Showing the original description.

Set up and authenticate the 1Password CLI, then supply stored passwords and API keys to commands or configuration. The skill covers desktop integration, service accounts, and interactive sign-in while keeping secrets out of chat and logs.

• Setting up the 1Password CLI
• Supplying API keys to commands
• Using service account authentication in CI

Write Rust unit, integration, and async tests using a test-first workflow. Covers generated test inputs, mock dependencies, performance benchmarks, and coverage checks to assess behavior and identify code that remains untested.

• Developing Rust functions with tests first
• Adding tests to existing code
• Testing async operations and timeouts

Write and organize F# unit and integration tests with xUnit, FsUnit, and Unquote. Use FsCheck to generate test inputs and check general rules, replace dependencies for isolated tests, and review test quality and coverage.

• Writing unit tests for F# code
• Checking general rules with generated inputs
• Testing ASP.NET Core API integration

Set up deployment checks for healthcare applications covering clinical decision support, patient information exposure, data integrity, workflows, and integrations. Block releases when critical tests fail, and flag lower workflow or integration pass rates for review.

• Checking an electronic health record application before deployment
• Testing changes to drug interactions or dose validation
• Checking patient data exposure after access control changes

Write and review C# and .NET tests using xUnit examples. Covers unit tests, mocks that replace dependencies, API and database integration tests, reusable test data, and project organization to check behavior and outcomes.

• Adding tests for C# services
• Testing ASP.NET Core APIs
• Checking database persistence

Helps you integrate hosted browser automation through Browser Use Cloud APIs and Python or TypeScript SDKs. Reference guides cover authentication, sessions, saved browser profiles, live views, and connections to existing agents or workflow services.

• Add cloud browser tasks to an app
• Give an existing agent browser access
• Manage login sessions and browser profiles

Build a narrowly scoped feature or integration using existing repository structures. Define observable acceptance criteria and non-goals, complete the working path across relevant layers, and stop when focused checks confirm the requested outcome.

• Building a feature within a clear scope
• Adding integrations using existing structures
• Defining acceptance criteria and non-goals

Configure a RuView sensing deployment, including WiFi settings, detection thresholds, processing on devices, and coordinated nodes. It covers device provisioning, server options, firmware variants, and Cognitum Seed integration to adjust how the system operates.

• Adjust WiFi channels and transmitter filters
• Tune presence, fall, and vital sensing settings
• Configure coordinated sensing across multiple nodes

Inspect local AGNTCY integration settings and summarize endpoint configuration, the optional SLIM package, transport status, and session counters in a short table. Distinguish available components from unimplemented features without making network calls or changing settings.

• Check whether AGNTCY is configured
• Review SLIM package and endpoint settings
• Inspect mod counters for the current project

Identify and test critical workflows where APIs, services, databases, and interface components work together. Review normal behavior, important failures, and CI checks to find gaps that isolated unit tests can miss and keep those interactions continuously verified.

• Testing interactions between APIs, services, and databases
• Checking components connected to state management
• Reviewing CI coverage for critical workflows

Test agent features across local and remote execution environments using integration tests, which check components working together. Covers Docker and Wine setups, test helpers, and configuration-specific skips for the app-server and exec-server split.

• Run core integration tests with a Docker remote executor
• Test a Windows exec-server under Wine
• Adapt app-server tests for remote execution

Control a running iTerm2 workspace from the command line. Inspect processes and directories across panes, send commands, read terminal history, arrange windows and tabs, and manage preferences or tmux integration.

• Check processes and directories across panes
• Send commands and read output history
• Create split panes and restore layouts

Fit probabilistic models to single-cell measurements for integration across experiments, cell annotation, combined RNA and protein or ATAC analysis, and gene expression comparisons. The skill covers input requirements, training checks, reference mapping, and interpretation of model uncertainty.

• Integrating single-cell RNA data across experimental batches
• Assigning cell labels using partial annotations or a reference
• Analyzing RNA with protein or ATAC measurements

Process calibrated one-dimensional NMR signals into spectra, candidate peaks, and signed integration results. Supports manual phase adjustment, baseline correction, and recorded processing settings so results can be reviewed and reproduced.

• Convert raw one-dimensional NMR signals into spectra
• Check peak positions against reference signals
• Review phase and baseline corrections

Design and build Apify integrations for workflow platforms, AI agents, AI frameworks, or applications. Follow guidance for authentication, asynchronous cloud task execution, result retrieval, spending limits, error handling, testing, and release preparation.

• Adding Apify actions to a workflow automation platform
• Building an Apify plugin for an AI agent
• Connecting an AI framework package to Apify

Build voice skills for Amazon Alexa and plan an assistant that uses Claude for its intelligence. Covers integration with AWS services including Lambda, DynamoDB, Polly, Transcribe, and Lex, as well as Smart Home.

• Developing voice skills for Amazon Alexa
• Building an Alexa assistant that uses Claude
• Planning Alexa integrations with AWS services

Add a new exchange integration to CCXT using TypeScript and established exchange templates. Follow guidance for unified methods, data conversion, authentication, sandbox settings, recorded API test data, documentation, and checks across generated language implementations.

• Add an exchange that CCXT does not yet support
• Convert exchange responses into CCXT's common data format
• Record real API responses for regression tests

Structure mobile apps built with React Native and Expo. Covers navigation, state management, device feature integration, offline data synchronization, and performance practices, helping developers organize projects and account for differences between iOS and Android.

• Structuring a new React Native or Expo app
• Designing tabs, authentication screens, and modals
• Planning device integrations and offline synchronization

Build Node.js APIs and backend services with Express/Fastify. The skill guides authentication, database integration, error handling, and operational practices such as logging and health checks, which report whether a service is working.

• Build a REST API with Express/Fastify
• Add authentication and database integration
• Organize middleware and error handling

Build NFT contracts using ERC-721 and ERC-1155, standards for unique assets and multiple token types. Covers issuance limits, descriptive metadata, marketplace integration, and royalty information for art collections, collectibles, and game items.

• Creating NFT art and collectible collections
• Managing multiple game item types
• Designing metadata storage and references

Organize feature development across multiple agents by dividing work, assigning one owner per file, and agreeing on interfaces before implementation. Provides strategies for shared files, branches, and integration so agents can build separate parts of the same system.

• Dividing a large feature among multiple agents
• Assigning file ownership to avoid conflicting edits
• Agreeing on APIs before parallel implementation

Create integration tests for .NET database access before migrating from Oracle to PostgreSQL. The tests record expected Oracle behavior with controlled test data and portable checks, providing a baseline for later migration validation.

• Recording Oracle behavior before migration
• Testing repository methods and stored procedure calls
• Checking empty strings, NULL inputs, and datetime precision