blob: 2874e6cfff509e0b1db1a4f5353064035f32057d [file] [log] [blame]
/*
*
* Copyright (c) 2022 Project CHIP Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// module headers
#import <Matter/Matter.h>
#import "MTRDeviceTestDelegate.h"
#import "MTRErrorTestUtils.h"
#import "MTRTestKeys.h"
#import "MTRTestResetCommissioneeHelper.h"
#import "MTRTestStorage.h"
// system dependencies
#import <XCTest/XCTest.h>
#if TARGET_OS_IPHONE || TARGET_OS_SIMULATOR
#define ENABLE_OTA_TESTS 0
#else
#define ENABLE_OTA_TESTS 1
#endif
// TODO: Disable test005_DoBDXTransferAllowUpdateRequest,
// test006_DoBDXTransferWithTwoOTARequesters and
// test007_DoBDXTransferIncrementalOtaUpdate until PR #26040 is merged.
// Currently the poll interval causes delays in the BDX transfer and
// results in the test taking a long time.
#ifdef ENABLE_REAL_OTA_UPDATE_TESTS
#undef ENABLE_REAL_OTA_UPDATE_TESTS
#endif
#if ENABLE_OTA_TESTS
static const uint16_t kPairingTimeoutInSeconds = 10;
static const uint16_t kTimeoutInSeconds = 3;
static const uint16_t kTimeoutWithUpdateInSeconds = 60;
static const uint64_t kDeviceId1 = 0x12341234;
static const uint64_t kDeviceId2 = 0x12341235;
#ifdef ENABLE_REAL_OTA_UPDATE_TESTS
static const uint64_t kDeviceId3 = 0x12341236;
#endif // ENABLE_REAL_OTA_UPDATE_TESTS
// NOTE: These onboarding payloads are for the chip-ota-requestor-app, not chip-all-clusters-app
static NSString * kOnboardingPayload1 = @"MT:-24J0SO527K10648G00"; // Discriminator: 1111
static NSString * kOnboardingPayload2 = @"MT:-24J0AFN00L10648G00"; // Discriminator: 1112
#ifdef ENABLE_REAL_OTA_UPDATE_TESTS
static NSString * kOnboardingPayload3 = @"MT:-24J0IRV01L10648G00"; // Discriminator: 1113
#endif // ENABLE_REAL_OTA_UPDATE_TESTS
static const uint16_t kLocalPort = 5541;
static const uint16_t kTestVendorId = 0xFFF1u;
static const uint16_t kOTAProviderEndpointId = 0;
static MTRDeviceController * sController = nil;
static NSNumber * kUpdatedSoftwareVersion_5 = @5;
static NSString * kUpdatedSoftwareVersionString_5 = @"5.0";
static NSNumber * kUpdatedSoftwareVersion_10 = @10;
static NSString * kUpdatedSoftwareVersionString_10 = @"10.0";
// kOtaRequestorBasePort gets the discriminator added to it to figure out the
// port the ota-requestor app should be using. This ensures that apps with
// distinct discriminators use distinct ports.
static const uint16_t kOtaRequestorBasePort = 5542 - 1111;
@class MTROTARequestorAppRunner;
@interface MTROTAProviderTests : XCTestCase
- (NSTask *)createTaskForPath:(NSString *)path;
- (NSString *)createImageFromRawImage:(NSString *)rawImage withVersion:(NSNumber *)version;
- (MTRDevice *)commissionDeviceWithPayload:(NSString *)payloadString nodeID:(NSNumber *)nodeID;
- (void)registerRunningRequestor:(MTROTARequestorAppRunner *)requestor;
@end
static unsigned sAppRunnerIndex = 1;
@interface MTROTARequestorAppRunner : NSObject
@property (nonatomic, copy) NSString * downloadFilePath;
- (instancetype)initWithPayload:(NSString *)payload testcase:(MTROTAProviderTests *)testcase;
- (MTRDevice *)commissionWithNodeID:(NSNumber *)nodeID;
@end
@implementation MTROTARequestorAppRunner {
unsigned _uniqueIndex;
NSTask * _appTask;
MTROTAProviderTests * _testcase;
NSString * _payload;
MTRDevice * commissionedDevice;
}
- (MTRDevice *)commissionWithNodeID:(NSNumber *)nodeID
{
return [_testcase commissionDeviceWithPayload:_payload nodeID:nodeID];
}
- (instancetype)initWithPayload:(NSString *)payload testcase:(MTROTAProviderTests *)testcase
{
if (!(self = [super init])) {
return nil;
}
_uniqueIndex = sAppRunnerIndex++;
_testcase = testcase;
_payload = payload;
_downloadFilePath = [NSString stringWithFormat:@"/tmp/chip-ota-requestor-downloaded-image%u", _uniqueIndex];
NSError * error;
__auto_type * parsedPayload = [MTRSetupPayload setupPayloadWithOnboardingPayload:payload error:&error];
XCTAssertNotNil(parsedPayload);
XCTAssertNil(error);
XCTAssertFalse(parsedPayload.hasShortDiscriminator);
__auto_type * discriminator = parsedPayload.discriminator;
_appTask = [testcase createTaskForPath:@"out/debug/ota-requestor-app/chip-ota-requestor-app"];
__auto_type * arguments = @[
@"--interface-id",
@"-1",
@"--secured-device-port",
[NSString stringWithFormat:@"%u", kOtaRequestorBasePort + discriminator.unsignedShortValue],
@"--discriminator",
[NSString stringWithFormat:@"%u", discriminator.unsignedShortValue],
@"--KVS",
[NSString stringWithFormat:@"/tmp/chip-ota-requestor-kvs%u", _uniqueIndex],
@"--otaDownloadPath",
_downloadFilePath,
@"--autoApplyImage",
];
[_appTask setArguments:arguments];
NSString * outFile = [NSString stringWithFormat:@"/tmp/darwin/framework-tests/ota-requestor-app-%u.log", _uniqueIndex];
NSString * errorFile = [NSString stringWithFormat:@"/tmp/darwin/framework-tests/ota-requestor-app-err-%u.log", _uniqueIndex];
// Make sure the files exist.
[[NSFileManager defaultManager] createFileAtPath:outFile contents:nil attributes:nil];
[[NSFileManager defaultManager] createFileAtPath:errorFile contents:nil attributes:nil];
_appTask.standardOutput = [NSFileHandle fileHandleForWritingAtPath:outFile];
_appTask.standardError = [NSFileHandle fileHandleForWritingAtPath:errorFile];
[_appTask launchAndReturnError:&error];
XCTAssertNil(error);
NSLog(@"Started requestor with arguments %@ stdout=%@ and stderr=%@", arguments, outFile, errorFile);
[_testcase registerRunningRequestor:self];
return self;
}
- (void)terminate
{
[_appTask terminate];
}
@end
@interface MTROTAProviderTestControllerDelegate : NSObject <MTRDeviceControllerDelegate>
@property (nonatomic, readonly) XCTestExpectation * expectation;
@property (nonatomic, readonly) NSNumber * commissioneeNodeID;
@end
@implementation MTROTAProviderTestControllerDelegate
- (id)initWithExpectation:(XCTestExpectation *)expectation commissioneeNodeID:(NSNumber *)nodeID
{
self = [super init];
if (self) {
_expectation = expectation;
_commissioneeNodeID = nodeID;
}
return self;
}
- (void)controller:(MTRDeviceController *)controller commissioningSessionEstablishmentDone:(NSError * _Nullable)error
{
XCTAssertEqual(error.code, 0);
NSError * commissionError = nil;
[sController commissionNodeWithID:self.commissioneeNodeID
commissioningParams:[[MTRCommissioningParameters alloc] init]
error:&commissionError];
XCTAssertNil(commissionError);
// Keep waiting for onCommissioningComplete
}
- (void)controller:(MTRDeviceController *)controller commissioningComplete:(NSError *)error
{
XCTAssertEqual(error.code, 0);
[_expectation fulfill];
_expectation = nil;
}
@end
typedef void (^QueryImageCompletion)(
MTROTASoftwareUpdateProviderClusterQueryImageResponseParams * _Nullable data, NSError * _Nullable error);
typedef void (^ApplyUpdateRequestCompletion)(
MTROTASoftwareUpdateProviderClusterApplyUpdateResponseParams * _Nullable data, NSError * _Nullable error);
typedef void (^BlockQueryCompletion)(NSData * _Nullable data, BOOL isEOF);
typedef void (^QueryImageHandler)(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion);
typedef void (^ApplyUpdateRequestHandler)(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterApplyUpdateRequestParams * params, ApplyUpdateRequestCompletion completion);
typedef void (^NotifyUpdateAppliedHandler)(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterNotifyUpdateAppliedParams * params, MTRStatusCompletion completion);
typedef void (^BDXTransferBeginHandler)(NSNumber * nodeID, MTRDeviceController * controller, NSString * fileDesignator,
NSNumber * offset, MTRStatusCompletion completion);
typedef void (^BDXQueryHandler)(NSNumber * nodeID, MTRDeviceController * controller, NSNumber * blockSize, NSNumber * blockIndex,
NSNumber * bytesToSkip, BlockQueryCompletion completion);
typedef void (^BDXTransferEndHandler)(NSNumber * nodeID, MTRDeviceController * controller, NSError * _Nullable error);
@interface MTROTAProviderDelegateImpl : NSObject <MTROTAProviderDelegate>
@property (nonatomic, nullable) QueryImageHandler queryImageHandler;
@property (nonatomic, nullable) ApplyUpdateRequestHandler applyUpdateRequestHandler;
@property (nonatomic, nullable) NotifyUpdateAppliedHandler notifyUpdateAppliedHandler;
@property (nonatomic, nullable) BDXTransferBeginHandler transferBeginHandler;
@property (nonatomic, nullable) BDXQueryHandler blockQueryHandler;
@property (nonatomic, nullable) BDXTransferEndHandler transferEndHandler;
@end
@implementation MTROTAProviderDelegateImpl
- (void)handleQueryImageForNodeID:(NSNumber *)nodeID
controller:(MTRDeviceController *)controller
params:(MTROTASoftwareUpdateProviderClusterQueryImageParams *)params
completion:(QueryImageCompletion)completion
{
XCTAssertEqual(controller, sController);
if (self.queryImageHandler) {
self.queryImageHandler(nodeID, controller, params, completion);
} else {
XCTFail(@"Unexpected attempt to query for an image");
[self respondNotAvailableWithCompletion:completion];
}
}
- (void)handleApplyUpdateRequestForNodeID:(NSNumber *)nodeID
controller:(MTRDeviceController *)controller
params:(MTROTASoftwareUpdateProviderClusterApplyUpdateRequestParams *)params
completion:(ApplyUpdateRequestCompletion)completion
{
XCTAssertEqual(controller, sController);
if (self.applyUpdateRequestHandler) {
self.applyUpdateRequestHandler(nodeID, controller, params, completion);
} else {
XCTFail(@"Unexpected attempt to apply an update");
[self respondWithErrorToApplyUpdateRequestWithCompletion:completion];
}
}
- (void)handleNotifyUpdateAppliedForNodeID:(NSNumber *)nodeID
controller:(MTRDeviceController *)controller
params:(MTROTASoftwareUpdateProviderClusterNotifyUpdateAppliedParams *)params
completion:(MTRStatusCompletion)completion
{
XCTAssertEqual(controller, sController);
if (self.notifyUpdateAppliedHandler) {
self.notifyUpdateAppliedHandler(nodeID, controller, params, completion);
} else {
XCTFail(@"Unexpected update application");
[self respondErrorWithCompletion:completion];
}
}
- (void)handleBDXTransferSessionBeginForNodeID:(NSNumber *)nodeID
controller:(MTRDeviceController *)controller
fileDesignator:(NSString *)fileDesignator
offset:(NSNumber *)offset
completion:(MTRStatusCompletion)completion
{
XCTAssertEqual(controller, sController);
if (self.transferBeginHandler) {
self.transferBeginHandler(nodeID, controller, fileDesignator, offset, completion);
} else {
XCTFail(@"Unexpected attempt to begin BDX transfer");
[self respondErrorWithCompletion:completion];
}
}
- (void)handleBDXQueryForNodeID:(NSNumber *)nodeID
controller:(MTRDeviceController *)controller
blockSize:(NSNumber *)blockSize
blockIndex:(NSNumber *)blockIndex
bytesToSkip:(NSNumber *)bytesToSkip
completion:(BlockQueryCompletion)completion
{
XCTAssertEqual(controller, sController);
if (self.blockQueryHandler) {
self.blockQueryHandler(nodeID, controller, blockSize, blockIndex, bytesToSkip, completion);
} else {
XCTFail(@"Unexpected attempt to get BDX block");
completion(nil, YES);
}
}
- (void)handleBDXTransferSessionEndForNodeID:(NSNumber *)nodeID
controller:(MTRDeviceController *)controller
error:(NSError * _Nullable)error
{
if (self.transferEndHandler) {
self.transferEndHandler(nodeID, controller, error);
} else {
XCTFail(@"Unexpected end of BDX transfer");
}
}
- (void)respondNotAvailableWithCompletion:(QueryImageCompletion)completion
{
__auto_type * responseParams = [[MTROTASoftwareUpdateProviderClusterQueryImageResponseParams alloc] init];
responseParams.status = @(MTROTASoftwareUpdateProviderStatusNotAvailable);
completion(responseParams, nil);
}
- (void)respondBusyWithDelay:(NSNumber *)delay completion:(QueryImageCompletion)completion
{
__auto_type * responseParams = [[MTROTASoftwareUpdateProviderClusterQueryImageResponseParams alloc] init];
responseParams.status = @(MTROTASoftwareUpdateProviderStatusBusy);
responseParams.delayedActionTime = delay;
completion(responseParams, nil);
}
- (void)respondAvailableWithDelay:(NSNumber *)delay
uri:(NSString *)uri
updateToken:(NSData *)updateToken
softwareVersion:(NSNumber *)softwareVersion
softwareVersionString:(NSString *)softwareVersionString
completion:(QueryImageCompletion)completion
{
__auto_type * responseParams = [[MTROTASoftwareUpdateProviderClusterQueryImageResponseParams alloc] init];
responseParams.status = @(MTROTASoftwareUpdateProviderStatusUpdateAvailable);
responseParams.delayedActionTime = delay;
responseParams.imageURI = uri;
// TODO: Figure out whether we need better
// SoftwareVersion/SoftwareVersionString/UpdateToken bits.
responseParams.softwareVersion = softwareVersion;
responseParams.softwareVersionString = softwareVersionString;
responseParams.updateToken = updateToken;
completion(responseParams, nil);
}
- (void)respondWithErrorToApplyUpdateRequestWithCompletion:(ApplyUpdateRequestCompletion)completion
{
[self respondErrorWithCompletion:^(NSError * _Nullable error) {
completion(nil, error);
}];
}
- (void)respondToApplyUpdateRequestWithAction:(MTROTASoftwareUpdateProviderApplyUpdateAction)action
completion:(ApplyUpdateRequestCompletion)completion
{
__auto_type * params = [[MTROTASoftwareUpdateProviderClusterApplyUpdateResponseParams alloc] init];
params.action = @(action);
params.delayedActionTime = @(0);
completion(params, nil);
}
- (void)respondErrorWithCompletion:(MTRStatusCompletion)completion
{
[self respondErrorWithCode:MTRErrorCodeGeneralError completion:completion];
}
- (void)respondErrorWithCode:(MTRErrorCode)code completion:(MTRStatusCompletion)completion
{
[self respondError:[NSError errorWithDomain:MTRErrorDomain code:code userInfo:nil] completion:completion];
}
- (void)respondError:(NSError *)error completion:(MTRStatusCompletion)completion
{
completion(error);
}
- (void)respondSuccess:(MTRStatusCompletion)completion
{
completion(nil);
}
- (NSData *)generateUpdateToken
{
const size_t dataSize = 16;
const size_t randomBytesAtOnce = sizeof(uint32_t);
XCTAssertEqual(dataSize % randomBytesAtOnce, 0);
NSMutableData * data = [NSMutableData dataWithCapacity:16];
for (unsigned i = 0; i < dataSize / randomBytesAtOnce; ++i) {
uint32_t randomBytes = arc4random();
[data appendBytes:&randomBytes length:randomBytesAtOnce];
}
return [NSData dataWithData:data];
}
@end
static MTROTAProviderDelegateImpl * sOTAProviderDelegate;
/**
* Helper that, given a raw image, creates an image-with-header from it, drives
* a BDX transfer, etc.
*/
@interface MTROTAProviderTransferChecker : NSObject
- (instancetype)initWithRawImagePath:(NSString *)rawImagePath
otaImageDownloadFilePath:(NSString *)otaImageDownloadFilePath
nodeID:(NSNumber *)nodeID
softwareVersion:(NSNumber *)softwareVersion
softwareVersionString:(NSString *)softwareVersionString
applyUpdateAction:(MTROTASoftwareUpdateProviderApplyUpdateAction)applyUpdateAction
testcase:(XCTestCase *)testcase;
@property (nonatomic, readonly) XCTestExpectation * queryExpectation;
@property (nonatomic, readonly) XCTestExpectation * bdxBeginExpectation;
@property (nonatomic, readonly) XCTestExpectation * bdxQueryExpectation;
@property (nonatomic, readonly) XCTestExpectation * bdxEndExpectation;
@property (nonatomic, readonly) XCTestExpectation * applyUpdateRequestExpectation;
@property (nonatomic, readonly) XCTestExpectation * notifyUpdateAppliedExpectation;
@end
@implementation MTROTAProviderTransferChecker
- (instancetype)initWithRawImagePath:(NSString *)rawImagePath
otaImageDownloadFilePath:(NSString *)otaImageDownloadFilePath
nodeID:(NSNumber *)nodeID
softwareVersion:(NSNumber *)softwareVersion
softwareVersionString:(NSString *)softwareVersionString
applyUpdateAction:(MTROTASoftwareUpdateProviderApplyUpdateAction)applyUpdateAction
testcase:(MTROTAProviderTests *)testcase
{
if (!(self = [super init])) {
return nil;
}
_queryExpectation = [testcase expectationWithDescription:@"handleQueryImageForNodeID called"];
_bdxBeginExpectation = [testcase expectationWithDescription:@"handleBDXTransferSessionBeginForNodeID called"];
_bdxQueryExpectation = [testcase expectationWithDescription:@"handleBDXQueryForNodeID called"];
_bdxEndExpectation = [testcase expectationWithDescription:@"handleBDXTransferSessionEndForNodeID called"];
_applyUpdateRequestExpectation = [testcase expectationWithDescription:@"handleApplyUpdateRequestForNodeID called"];
_notifyUpdateAppliedExpectation = [testcase expectationWithDescription:@"handleNotifyUpdateAppliedForNodeID called"];
NSString * imagePath = [testcase createImageFromRawImage:rawImagePath withVersion:softwareVersion];
NSData * updateToken = [sOTAProviderDelegate generateUpdateToken];
__block NSFileHandle * readHandle;
__block uint64_t imageSize;
__block uint32_t lastBlockIndex = UINT32_MAX;
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
XCTAssertEqualObjects(nodeID, nodeID);
XCTAssertEqual(controller, sController);
sOTAProviderDelegate.queryImageHandler = nil;
[sOTAProviderDelegate respondAvailableWithDelay:@(0)
uri:imagePath
updateToken:updateToken
softwareVersion:softwareVersion
softwareVersionString:softwareVersionString
completion:completion];
[self.queryExpectation fulfill];
};
sOTAProviderDelegate.transferBeginHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSString * fileDesignator,
NSNumber * offset, MTRStatusCompletion completion) {
XCTAssertEqualObjects(nodeID, nodeID);
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(fileDesignator, imagePath);
XCTAssertEqualObjects(offset, @(0));
readHandle = [NSFileHandle fileHandleForReadingAtPath:fileDesignator];
XCTAssertNotNil(readHandle);
NSError * endSeekError;
XCTAssertTrue([readHandle seekToEndReturningOffset:&imageSize error:&endSeekError]);
XCTAssertNil(endSeekError);
sOTAProviderDelegate.transferBeginHandler = nil;
[sOTAProviderDelegate respondSuccess:completion];
[self.bdxBeginExpectation fulfill];
};
sOTAProviderDelegate.blockQueryHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSNumber * blockSize,
NSNumber * blockIndex, NSNumber * bytesToSkip, BlockQueryCompletion completion) {
XCTAssertEqualObjects(nodeID, nodeID);
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(blockSize, @(1024)); // Seems to always be 1024.
XCTAssertEqualObjects(blockIndex, @(lastBlockIndex + 1));
XCTAssertEqualObjects(bytesToSkip, @(0)); // Don't expect to see skips here.
// Make sure we actually end up with multiple blocks.
XCTAssertTrue(blockSize.unsignedLongLongValue < imageSize);
XCTAssertNotNil(readHandle);
uint64_t offset = blockSize.unsignedLongLongValue * blockIndex.unsignedLongLongValue;
NSError * seekError = nil;
[readHandle seekToOffset:offset error:&seekError];
XCTAssertNil(seekError);
NSError * readError = nil;
NSData * data = [readHandle readDataUpToLength:blockSize.unsignedLongValue error:&readError];
XCTAssertNil(readError);
XCTAssertNotNil(data);
BOOL isEOF = offset + blockSize.unsignedLongValue >= imageSize;
++lastBlockIndex;
if (isEOF) {
sOTAProviderDelegate.blockQueryHandler = nil;
}
completion(data, isEOF);
if (isEOF) {
[self.bdxQueryExpectation fulfill];
}
};
sOTAProviderDelegate.transferEndHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSError * _Nullable error) {
XCTAssertEqualObjects(nodeID, nodeID);
XCTAssertEqual(controller, sController);
XCTAssertNil(error);
sOTAProviderDelegate.transferEndHandler = nil;
[self.bdxEndExpectation fulfill];
};
sOTAProviderDelegate.applyUpdateRequestHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterApplyUpdateRequestParams * params, ApplyUpdateRequestCompletion completion) {
XCTAssertEqualObjects(nodeID, nodeID);
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(params.updateToken, updateToken);
XCTAssertEqualObjects(params.newVersion, softwareVersion);
XCTAssertTrue([[NSFileManager defaultManager] contentsEqualAtPath:rawImagePath andPath:otaImageDownloadFilePath]);
sOTAProviderDelegate.applyUpdateRequestHandler = nil;
[sOTAProviderDelegate respondToApplyUpdateRequestWithAction:applyUpdateAction completion:completion];
[self.applyUpdateRequestExpectation fulfill];
};
if (applyUpdateAction == MTROTASoftwareUpdateProviderApplyUpdateActionProceed) {
sOTAProviderDelegate.notifyUpdateAppliedHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterNotifyUpdateAppliedParams * params, MTRStatusCompletion completion) {
XCTAssertEqualObjects(nodeID, nodeID);
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(params.updateToken, updateToken);
XCTAssertEqualObjects(params.softwareVersion, softwareVersion);
sOTAProviderDelegate.notifyUpdateAppliedHandler = nil;
[sOTAProviderDelegate respondSuccess:completion];
[self.notifyUpdateAppliedExpectation fulfill];
};
}
return self;
}
@end
static BOOL sStackInitRan = NO;
static BOOL sNeedsStackShutdown = YES;
@implementation MTROTAProviderTests {
NSMutableSet<NSNumber *> * _commissionedNodeIDs;
NSMutableSet<MTROTARequestorAppRunner *> * _runningRequestors;
}
+ (void)tearDown
{
// Global teardown, runs once
if (sNeedsStackShutdown) {
// We don't need to worry about ResetCommissionee. If we get here,
// we're running only one of our test methods (using
// -only-testing:MatterTests/MTROTAProviderTests/testMethodName), since
// we did not run test999_TearDown.
[self shutdownStack];
}
}
- (void)setUp
{
// Per-test setup, runs before each test.
[super setUp];
[self setContinueAfterFailure:NO];
if (sStackInitRan == NO) {
[self initStack];
}
_commissionedNodeIDs = [[NSMutableSet alloc] init];
_runningRequestors = [[NSMutableSet alloc] init];
XCTAssertNil(sOTAProviderDelegate.queryImageHandler);
XCTAssertNil(sOTAProviderDelegate.applyUpdateRequestHandler);
XCTAssertNil(sOTAProviderDelegate.notifyUpdateAppliedHandler);
XCTAssertNil(sOTAProviderDelegate.transferBeginHandler);
XCTAssertNil(sOTAProviderDelegate.blockQueryHandler);
XCTAssertNil(sOTAProviderDelegate.transferEndHandler);
// Start a new controller for each test, with a new fabric. Otherwise
// reusing the same node id for our commissionee devices will cause us to
// try to reuse sessions in ways that fail.
__auto_type * testKeys = [[MTRTestKeys alloc] init];
XCTAssertNotNil(testKeys);
__auto_type * params = [[MTRDeviceControllerStartupParams alloc] initWithIPK:testKeys.ipk fabricID:@(1) nocSigner:testKeys];
params.vendorID = @(kTestVendorId);
MTRDeviceController * controller = [[MTRDeviceControllerFactory sharedInstance] createControllerOnNewFabric:params error:nil];
XCTAssertNotNil(controller);
XCTAssertTrue([controller isRunning]);
sController = controller;
}
- (void)tearDown
{
for (NSNumber * nodeID in _commissionedNodeIDs) {
__auto_type * device = [MTRBaseDevice deviceWithNodeID:nodeID controller:sController];
ResetCommissionee(device, dispatch_get_main_queue(), self, kTimeoutInSeconds);
}
for (MTROTARequestorAppRunner * runner in _runningRequestors) {
[runner terminate];
}
// Break cycle.
_runningRequestors = nil;
if (sController != nil) {
[sController shutdown];
XCTAssertFalse([sController isRunning]);
sController = nil;
}
// Per-test teardown, runs after each test.
[super tearDown];
// Reset all handlers so tests don't interfere with each other.
sOTAProviderDelegate.queryImageHandler = nil;
sOTAProviderDelegate.applyUpdateRequestHandler = nil;
sOTAProviderDelegate.notifyUpdateAppliedHandler = nil;
sOTAProviderDelegate.transferBeginHandler = nil;
sOTAProviderDelegate.blockQueryHandler = nil;
sOTAProviderDelegate.transferEndHandler = nil;
}
- (MTRDevice *)commissionDeviceWithPayload:(NSString *)payloadString nodeID:(NSNumber *)nodeID
{
XCTestExpectation * expectation =
[self expectationWithDescription:[NSString stringWithFormat:@"Commissioning Complete for %@", nodeID]];
__auto_type * deviceControllerDelegate = [[MTROTAProviderTestControllerDelegate alloc] initWithExpectation:expectation
commissioneeNodeID:nodeID];
dispatch_queue_t callbackQueue = dispatch_queue_create("com.chip.device_controller_delegate", DISPATCH_QUEUE_SERIAL);
[sController setDeviceControllerDelegate:deviceControllerDelegate queue:callbackQueue];
NSError * error;
__auto_type * payload = [MTRSetupPayload setupPayloadWithOnboardingPayload:payloadString error:&error];
XCTAssertNotNil(payload);
XCTAssertNil(error);
[sController setupCommissioningSessionWithPayload:payload newNodeID:nodeID error:&error];
XCTAssertNil(error);
[self waitForExpectations:@[ expectation ] timeout:kPairingTimeoutInSeconds];
[_commissionedNodeIDs addObject:nodeID];
return [MTRDevice deviceWithNodeID:nodeID controller:sController];
}
- (void)registerRunningRequestor:(MTROTARequestorAppRunner *)requestor
{
[_runningRequestors addObject:requestor];
}
- (void)initStack
{
sStackInitRan = YES;
__auto_type * factory = [MTRDeviceControllerFactory sharedInstance];
XCTAssertNotNil(factory);
__auto_type * storage = [[MTRTestStorage alloc] init];
sOTAProviderDelegate = [[MTROTAProviderDelegateImpl alloc] init];
__auto_type * factoryParams = [[MTRDeviceControllerFactoryParams alloc] initWithStorage:storage];
factoryParams.port = @(kLocalPort);
factoryParams.otaProviderDelegate = sOTAProviderDelegate;
factoryParams.shouldStartServer = YES;
BOOL ok = [factory startControllerFactory:factoryParams error:nil];
XCTAssertTrue(ok);
}
+ (void)shutdownStack
{
sNeedsStackShutdown = NO;
[[MTRDeviceControllerFactory sharedInstance] stopControllerFactory];
}
/**
* Given a path relative to the Matter root, create an absolute path to the file.
*/
- (NSString *)absolutePathFor:(NSString *)matterRootRelativePath
{
// Find the right absolute path to our file. PWD should
// point to our src/darwin/Framework.
NSString * pwd = [[NSProcessInfo processInfo] environment][@"PWD"];
NSMutableArray * pathComponents = [[NSMutableArray alloc] init];
[pathComponents addObject:[pwd substringToIndex:(pwd.length - @"src/darwin/Framework".length)]];
[pathComponents addObjectsFromArray:[matterRootRelativePath pathComponents]];
return [NSString pathWithComponents:pathComponents];
}
/**
* Create a task given a path relative to the Matter root.
*/
- (NSTask *)createTaskForPath:(NSString *)path
{
NSTask * task = [[NSTask alloc] init];
[task setLaunchPath:[self absolutePathFor:path]];
return task;
}
/**
* Runs a task to completion and makes sure it succeeds.
*/
- (void)runTask:(NSTask *)task
{
NSError * launchError;
[task launchAndReturnError:&launchError];
XCTAssertNil(launchError);
[task waitUntilExit];
XCTAssertEqual([task terminationStatus], 0);
}
/**
* Returns path to the raw image.
*/
- (NSString *)createRawImageWithVersion:(NSNumber *)version
{
NSTask * buildTask = [self createTaskForPath:@"scripts/examples/gn_build_example.sh"];
NSString * objdir =
[self absolutePathFor:[NSString stringWithFormat:@"out/debug/ota-requestor-app-v%u", version.unsignedIntValue]];
[buildTask setArguments:@[
[self absolutePathFor:@"examples/ota-requestor-app/linux"],
objdir,
@"chip_config_network_layer_ble=false",
@"non_spec_compliant_ota_action_delay_floor=0",
[NSString stringWithFormat:@"chip_device_config_device_software_version=%u", version.unsignedIntValue],
[NSString stringWithFormat:@"chip_device_config_device_software_version_string=\"%u.0\"", version.unsignedIntValue],
]];
[self runTask:buildTask];
NSString * sourcePath = [NSString pathWithComponents:@[ objdir, @"chip-ota-requestor-app" ]];
NSString * destPath = [NSString stringWithFormat:@"/tmp/ota-raw-image-v%u", version.unsignedIntValue];
// We don't care about error on remove; the file might not be there. But if
// it _is_ there, we have to remove, or the copy will fail.
[[NSFileManager defaultManager] removeItemAtPath:destPath error:nil];
NSError * copyError;
BOOL ok = [[NSFileManager defaultManager] copyItemAtPath:sourcePath toPath:destPath error:&copyError];
XCTAssertNil(copyError);
XCTAssertTrue(ok);
return destPath;
}
/**
* Returns path to the created image.
*/
- (NSString *)createImageFromRawImage:(NSString *)rawImage withVersion:(NSNumber *)version
{
NSString * image = [rawImage stringByReplacingOccurrencesOfString:@"raw-image" withString:@"image"];
NSTask * task = [self createTaskForPath:@"src/app/ota_image_tool.py"];
[task setArguments:@[
@"create", @"-v", @"0xFFF1", @"-p", @"0x8001", @"-vn", version.stringValue, @"-vs",
[NSString stringWithFormat:@"%.1f", version.floatValue], @"-da", @"sha256", rawImage, image
]];
[self runTask:task];
return image;
}
- (void)test000_SetUp
{
// Nothing to do here; our setUp method handled this already. This test
// just exists to make the setup not look like it's happening inside other
// tests.
}
- (XCTestExpectation *)announceProviderToDevice:(MTRDevice *)device
{
dispatch_queue_t queue = dispatch_get_main_queue();
XCTestExpectation * responseExpectation =
[self expectationWithDescription:[NSString stringWithFormat:@"AnnounceOTAProvider to %@ succeeded", device]];
__auto_type * params = [[MTROTASoftwareUpdateRequestorClusterAnnounceOTAProviderParams alloc] init];
params.providerNodeID = [sController controllerNodeID];
params.vendorID = @(kTestVendorId);
params.announcementReason = @(MTROTASoftwareUpdateRequestorAnnouncementReasonSimpleAnnouncement);
params.endpoint = @(kOTAProviderEndpointId);
__auto_type * cluster = [[MTRClusterOTASoftwareUpdateRequestor alloc] initWithDevice:device endpointID:@(0) queue:queue];
[cluster announceOTAProviderWithParams:params
expectedValues:nil
expectedValueInterval:nil
completion:^(NSError * _Nullable error) {
XCTAssertNil(error);
[responseExpectation fulfill];
}];
return responseExpectation;
}
- (void)test001_ReceiveQueryImageRequest_RespondUpdateNotAvailable
{
// Test that if we advertise ourselves as a provider we end up getting a
// QueryImage callbacks that we can respond to.
__auto_type * runner = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload1 testcase:self];
__auto_type * device = [runner commissionWithNodeID:@(kDeviceId1)];
XCTestExpectation * queryExpectation = [self expectationWithDescription:@"handleQueryImageForNodeID called"];
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
[sOTAProviderDelegate respondNotAvailableWithCompletion:completion];
[queryExpectation fulfill];
};
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation = [self announceProviderToDevice:device];
[self waitForExpectations:@[ queryExpectation, announceResponseExpectation ] timeout:kTimeoutInSeconds];
sOTAProviderDelegate.queryImageHandler = nil;
}
- (void)test002_ReceiveTwoQueryImageRequests_RespondExplicitBusy
{
// Test that if we advertise ourselves as a provider and respond BUSY to
// QueryImage callback, then we get a second QueryImage callback later on
// that we can then respond to however we wish.
__auto_type * runner = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload1 testcase:self];
__auto_type * device = [runner commissionWithNodeID:@(kDeviceId1)];
XCTestExpectation * queryExpectation1 = [self expectationWithDescription:@"handleQueryImageForNodeID called first time"];
XCTestExpectation * queryExpectation2 = [self expectationWithDescription:@"handleQueryImageForNodeID called second time"];
const uint16_t busyDelay = 1; // 1 second
__block QueryImageHandler handleSecondQuery;
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
sOTAProviderDelegate.queryImageHandler = handleSecondQuery;
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
[sOTAProviderDelegate respondBusyWithDelay:@(busyDelay) completion:completion];
[queryExpectation1 fulfill];
};
handleSecondQuery = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
[sOTAProviderDelegate respondNotAvailableWithCompletion:completion];
[queryExpectation2 fulfill];
};
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation = [self announceProviderToDevice:device];
// Make sure we get our queries in order. Give it a bit more time, because
// there will be a delay between the two queries.
[self waitForExpectations:@[ queryExpectation1, queryExpectation2 ] timeout:(kTimeoutInSeconds + busyDelay) enforceOrder:YES];
[self waitForExpectations:@[ announceResponseExpectation ] timeout:kTimeoutInSeconds];
}
- (void)test003_ReceiveQueryImageRequestWhileHandlingBDX_RespondImplicitBusy
{
// In this test we do the following:
//
// 1) Advertise ourselves to device1.
// 2) When device1 queries for an image, claim to have one.
// 3) When device1 tries to start a bdx transfer, stall it and advertise to device2.
// 4) When device2 queries for an image, claim to have one. Since we are
// in the middle of doing BDX with device1, this actually responds with Busy.
// 5) Error out of the device1 transfer.
// 6) Wait for device2 to query us again.
__auto_type * runner1 = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload1 testcase:self];
__auto_type * device1 = [runner1 commissionWithNodeID:@(kDeviceId1)];
__auto_type * runner2 = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload2 testcase:self];
__auto_type * device2 = [runner2 commissionWithNodeID:@(kDeviceId2)];
__block XCTestExpectation * announceResponseExpectation2;
XCTestExpectation * queryExpectation1 = [self expectationWithDescription:@"handleQueryImageForNodeID called first time"];
XCTestExpectation * queryExpectation2 = [self expectationWithDescription:@"handleQueryImageForNodeID called second time"];
XCTestExpectation * queryExpectation3 = [self expectationWithDescription:@"handleQueryImageForNodeID called third time"];
const uint16_t busyDelay = 1; // 1 second
NSString * fakeImageURI = @"No such image, really";
__block QueryImageHandler handleThirdQuery;
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
[sOTAProviderDelegate respondAvailableWithDelay:@(0)
uri:fakeImageURI
updateToken:[sOTAProviderDelegate generateUpdateToken]
softwareVersion:kUpdatedSoftwareVersion_5
softwareVersionString:kUpdatedSoftwareVersionString_5
completion:completion];
[queryExpectation1 fulfill];
};
sOTAProviderDelegate.transferBeginHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSString * fileDesignator,
NSNumber * offset, MTRStatusCompletion outerCompletion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
// Don't actually respond until the second requestor has queried us for
// an image. We need to reset queryImageHandler here, so we can close
// over outerCompletion.
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion innerCompletion) {
sOTAProviderDelegate.queryImageHandler = handleThirdQuery;
sOTAProviderDelegate.transferBeginHandler = nil;
XCTAssertEqualObjects(nodeID, @(kDeviceId2));
XCTAssertEqual(controller, sController);
// We respond UpdateAvailable, but since we are in the middle of
// handling OTA for device1 we expect the requestor to get Busy and
// try again.
[sOTAProviderDelegate respondAvailableWithDelay:@(busyDelay)
uri:fakeImageURI
updateToken:[sOTAProviderDelegate generateUpdateToken]
softwareVersion:kUpdatedSoftwareVersion_5
softwareVersionString:kUpdatedSoftwareVersionString_5
completion:innerCompletion];
[sOTAProviderDelegate respondErrorWithCompletion:outerCompletion];
[queryExpectation2 fulfill];
};
announceResponseExpectation2 = [self announceProviderToDevice:device2];
};
handleThirdQuery = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId2));
XCTAssertEqual(controller, sController);
[sOTAProviderDelegate respondNotAvailableWithCompletion:completion];
[queryExpectation3 fulfill];
};
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation1 = [self announceProviderToDevice:device1];
// Make sure we get our queries in order. Give it a bit more time, because
// there will be a delay between the two queries.
[self waitForExpectations:@[ queryExpectation1, queryExpectation2, queryExpectation3 ]
timeout:(kTimeoutInSeconds + busyDelay * 3)
enforceOrder:YES];
[self waitForExpectations:@[ announceResponseExpectation1, announceResponseExpectation2 ] timeout:kTimeoutInSeconds];
}
- (void)test004_DoBDXTransferDenyUpdateRequest
{
// In this test we do the following:
//
// 1) Create an actual image we can send to the device, with a valid header
// but garbage data.
// 2) Advertise ourselves to device.
// 3) When device queries for an image, claim to have one.
// 4) When device tries to start a bdx transfer, respond with success.
// 5) Send the data as the BDX transfer proceeds.
// 6) When device invokes ApplyUpdateRequest, respond with Discontinue so
// that the update does not actually proceed.
__auto_type * runner = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload1 testcase:self];
__auto_type * device = [runner commissionWithNodeID:@(kDeviceId1)];
// First, create an image. Make it at least 4096 bytes long, so we get
// multiple BDX blocks going.
const size_t rawImageSize = 4112;
NSData * rawImagePiece = [@"1234567890abcdef" dataUsingEncoding:NSUTF8StringEncoding];
XCTAssertEqual(rawImageSize % rawImagePiece.length, 0);
NSMutableData * fakeImage = [NSMutableData dataWithCapacity:rawImageSize];
while (fakeImage.length < rawImageSize) {
[fakeImage appendData:rawImagePiece];
}
NSString * rawImagePath = @"/tmp/ota-test004-raw-image";
[[NSFileManager defaultManager] createFileAtPath:rawImagePath contents:fakeImage attributes:nil];
__auto_type * checker =
[[MTROTAProviderTransferChecker alloc] initWithRawImagePath:rawImagePath
otaImageDownloadFilePath:runner.downloadFilePath
nodeID:@(kDeviceId1)
softwareVersion:kUpdatedSoftwareVersion_5
softwareVersionString:kUpdatedSoftwareVersionString_5
applyUpdateAction:MTROTASoftwareUpdateProviderApplyUpdateActionDiscontinue
testcase:self];
// We do not expect the update to actually be applied here.
checker.notifyUpdateAppliedExpectation.inverted = YES;
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation = [self announceProviderToDevice:device];
// Make sure we get our callbacks in order. Give it a bit more time, because
// we want to allow time for the BDX download.
[self waitForExpectations:@[ checker.queryExpectation, checker.bdxBeginExpectation, checker.bdxQueryExpectation ]
timeout:(kTimeoutWithUpdateInSeconds) enforceOrder:YES];
// Nothing really defines the ordering of bdxEndExpectation and
// applyUpdateRequestExpectation with respect to each other, and nothing
// defines the ordering of announceResponseExpectation with respect to _any_
// of the above expectations.
[self waitForExpectations:@[ checker.bdxEndExpectation, checker.applyUpdateRequestExpectation, announceResponseExpectation ]
timeout:kTimeoutInSeconds];
// We are not expecting checker.notifyUpdateAppliedExpectation to actually
// be called fulfilled, but we still need to wait on it here. Since we set
// inverted = YES, on it, this is basically a no-op, except for making
// XCTest not complain about unwaited expectations.
[self waitForExpectations:@[ checker.notifyUpdateAppliedExpectation ] timeout:kTimeoutInSeconds];
}
// TODO: Enable tests 005, 006 and 007 when PR #26040 is merged. Currently the poll interval causes delays in the BDX transfer
// and results in the tests taking a long time. With PR #26040 we eliminate the poll interval completely and hence the tests can run
// in a short time.
#ifdef ENABLE_REAL_OTA_UPDATE_TESTS
- (void)test005_DoBDXTransferAllowUpdateRequest
{
// In this test we do the following:
//
// 1) Check if the ota image file and raw image file required for this test exist.
// 2) Advertise ourselves to device.
// 3) When device queries for an image, pass the image path for the ota file generated beforehand as a pre-requisite
// 4) When device tries to start a bdx transfer, respond with success.
// 5) Send the data as the BDX transfer proceeds.
// 6) Confirm the downloaded ota image matches the raw image file that was generated before the test was run as a pre-requisite
// 7) When device invokes ApplyUpdateRequest, respond with Proceed so that the update proceeds
// 8) Wait for the app to restart and wait for the NotifyUpdateApplied message to confirm the app has updated to the new version
NSString * otaRawImagePath = [self createRawImageWithVersion:kUpdatedSoftwareVersion_5];
// Check whether the ota raw image exists at otaRawImagePath
XCTAssertTrue([[NSFileManager defaultManager] fileExistsAtPath:otaRawImagePath]);
__auto_type * runner = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload1 testcase:self];
__auto_type * device = [runner commissionWithNodeID:@(kDeviceId1)];
__auto_type * checker =
[[MTROTAProviderTransferChecker alloc] initWithRawImagePath:otaRawImagePath
otaImageDownloadFilePath:runner.downloadFilePath
nodeID:@(kDeviceId1)
softwareVersion:kUpdatedSoftwareVersion_5
softwareVersionString:kUpdatedSoftwareVersionString_5
applyUpdateAction:MTROTASoftwareUpdateProviderApplyUpdateActionProceed
testcase:self];
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation = [self announceProviderToDevice:device];
// Make sure we get our callbacks in order. Give it a bit more time, because
// we want to allow time for the BDX download.
[self waitForExpectations:@[
checker.queryExpectation, checker.bdxBeginExpectation, checker.bdxQueryExpectation, checker.bdxEndExpectation
]
timeout:(kTimeoutWithUpdateInSeconds) enforceOrder:YES];
// Nothing really defines the ordering of bdxEndExpectation and
// applyUpdateRequestExpectation with respect to each other.
[self waitForExpectations:@[ checker.applyUpdateRequestExpectation, checker.notifyUpdateAppliedExpectation ]
timeout:kTimeoutInSeconds
enforceOrder:YES];
// Nothing defines the ordering of announceResponseExpectation with respect
// to _any_ of the above expectations.
[self waitForExpectations:@[ announceResponseExpectation ] timeout:kTimeoutInSeconds];
}
- (void)test006_DoBDXTransferWithTwoOTARequesters
{
// In this test, we test BDX transfers between one provider and two OTA requestors device1 and device2.
//
// 1) We announce ourselves to device1 first.
// 2) When device1 queries, we return image available at imagePath1.
// 3) We set the BDX begin and end handlers for device1 and device1 starts the BDX transfer.
// 4) At this time, we announce ourselves to device2.
// 5) When device2 queries, we return image available with a busy delay of 30 secs.
// 6) When device1 completes the BDX transfer, we wait for device2 to query.
// 7) When device 2 queries again, we return image available at imagePath2.
// 8) We set the BDX begin and end handlers for device2 and device2 starts the BDX transfer.
// 9) Device1 applies the update independently and reboots with the new image.
// 10) At this point, we set the apply update handlers for device2.
// 11) Device2 applies the update and reboots with its new image.
NSString * otaRawImagePath1 = [self createRawImageWithVersion:kUpdatedSoftwareVersion_10];
NSString * otaRawImagePath2 = [self createRawImageWithVersion:kUpdatedSoftwareVersion_5];
// Check whether the ota raw image exists at otaRawImagePath1 and otaRawImagePath2
XCTAssertTrue([[NSFileManager defaultManager] fileExistsAtPath:otaRawImagePath1]);
XCTAssertTrue([[NSFileManager defaultManager] fileExistsAtPath:otaRawImagePath2]);
XCTestExpectation * queryExpectation1 = [self expectationWithDescription:@"handleQueryImageForNodeID called for device1"];
XCTestExpectation * queryExpectation2 =
[self expectationWithDescription:@"handleQueryImageForNodeID called for device2 - busy"];
XCTestExpectation * queryExpectation3 =
[self expectationWithDescription:@"handleQueryImageForNodeID called for device2 - available"];
XCTestExpectation * bdxBeginExpectation1 =
[self expectationWithDescription:@"handleBDXTransferSessionBeginForNodeID called for device1"];
XCTestExpectation * bdxBeginExpectation2 =
[self expectationWithDescription:@"handleBDXTransferSessionBeginForNodeID called for device2"];
XCTestExpectation * bdxQueryExpectation1 = [self expectationWithDescription:@"handleBDXQueryForNodeID called for device1"];
XCTestExpectation * bdxQueryExpectation2 = [self expectationWithDescription:@"handleBDXQueryForNodeID called for device2"];
XCTestExpectation * bdxEndExpectation1 =
[self expectationWithDescription:@"handleBDXTransferSessionEndForNodeID called for device1"];
XCTestExpectation * bdxEndExpectation2 =
[self expectationWithDescription:@"handleBDXTransferSessionEndForNodeID called for device2"];
XCTestExpectation * applyUpdateRequestExpectation1 =
[self expectationWithDescription:@"handleApplyUpdateRequestForNodeID called for device1"];
XCTestExpectation * applyUpdateRequestExpectation2 =
[self expectationWithDescription:@"handleApplyUpdateRequestForNodeID called for device2"];
XCTestExpectation * notifyUpdateAppliedExpectation1 =
[self expectationWithDescription:@"handleNotifyUpdateAppliedForNodeID called for device1"];
XCTestExpectation * notifyUpdateAppliedExpectation2 =
[self expectationWithDescription:@"handleNotifyUpdateAppliedForNodeID called for device2"];
__block XCTestExpectation * announceResponseExpectation2;
NSString * imagePath1 = [self createImageFromRawImage:otaRawImagePath1 withVersion:kUpdatedSoftwareVersion_10];
NSString * imagePath2 = [self createImageFromRawImage:otaRawImagePath2 withVersion:kUpdatedSoftwareVersion_5];
NSData * updateToken1 = [sOTAProviderDelegate generateUpdateToken];
NSData * updateToken2 = [sOTAProviderDelegate generateUpdateToken];
__block NSFileHandle * readHandle;
__block uint64_t imageSize;
__block uint32_t lastBlockIndex = UINT32_MAX;
const uint16_t busyDelay = 30; // 30 second
__auto_type * runner1 = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload1 testcase:self];
__auto_type * device1 = [runner1 commissionWithNodeID:@(kDeviceId1)];
__auto_type * runner2 = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload2 testcase:self];
__auto_type * device2 = [runner2 commissionWithNodeID:@(kDeviceId2)];
// This to keep track of whether queryImageHandler for device 2 was called or not. The first time it's called we will
// fulfill queryExpectation2 and proceed with BDX for device 1.
__block bool firstQueryImageForDevice2Received = false;
// Set up the query handler for device 1 to return image available at imagePath1
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
sOTAProviderDelegate.queryImageHandler = nil;
[sOTAProviderDelegate respondAvailableWithDelay:@(0)
uri:imagePath1
updateToken:updateToken1
softwareVersion:kUpdatedSoftwareVersion_10
softwareVersionString:kUpdatedSoftwareVersionString_10
completion:completion];
[queryExpectation1 fulfill];
};
// Set up the BDX transfer begin, block query and transfer end handlers for device1 so it can go ahead with the BDX transfer
sOTAProviderDelegate.transferBeginHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSString * fileDesignator,
NSNumber * offset, MTRStatusCompletion outerCompletion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(fileDesignator, imagePath1);
XCTAssertEqualObjects(offset, @(0));
readHandle = [NSFileHandle fileHandleForReadingAtPath:fileDesignator];
XCTAssertNotNil(readHandle);
NSError * endSeekError;
XCTAssertTrue([readHandle seekToEndReturningOffset:&imageSize error:&endSeekError]);
XCTAssertNil(endSeekError);
sOTAProviderDelegate.transferBeginHandler = nil;
// Don't actually respond until the second requestor has queried us for
// an image to ensure BDX for device1 starts only after device2 has queried us once.
// Set up the query handler for device2 to return image available at imagePath2 but a busy delay of 30 secs
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion innerCompletion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId2));
XCTAssertEqual(controller, sController);
[sOTAProviderDelegate respondAvailableWithDelay:@(busyDelay)
uri:imagePath2
updateToken:updateToken2
softwareVersion:kUpdatedSoftwareVersion_5
softwareVersionString:kUpdatedSoftwareVersionString_5
completion:innerCompletion];
if (!firstQueryImageForDevice2Received) {
[queryExpectation2 fulfill];
// Respond with success for the tranfer begin completion for device1
[sOTAProviderDelegate respondSuccess:outerCompletion];
[bdxBeginExpectation1 fulfill];
}
firstQueryImageForDevice2Received = true;
};
// Announce ourselves to device2
announceResponseExpectation2 = [self announceProviderToDevice:device2];
};
sOTAProviderDelegate.blockQueryHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSNumber * blockSize,
NSNumber * blockIndex, NSNumber * bytesToSkip, BlockQueryCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(blockSize, @(1024)); // Seems to always be 1024.
XCTAssertEqualObjects(blockIndex, @(lastBlockIndex + 1));
XCTAssertEqualObjects(bytesToSkip, @(0)); // Don't expect to see skips here.
// Make sure we actually end up with multiple blocks.
XCTAssertTrue(blockSize.unsignedLongLongValue < imageSize);
XCTAssertNotNil(readHandle);
uint64_t offset = blockSize.unsignedLongLongValue * blockIndex.unsignedLongLongValue;
NSError * seekError = nil;
[readHandle seekToOffset:offset error:&seekError];
XCTAssertNil(seekError);
NSError * readError = nil;
NSData * data = [readHandle readDataUpToLength:blockSize.unsignedLongValue error:&readError];
XCTAssertNil(readError);
XCTAssertNotNil(data);
BOOL isEOF = offset + blockSize.unsignedLongValue >= imageSize;
++lastBlockIndex;
if (isEOF) {
sOTAProviderDelegate.blockQueryHandler = nil;
}
completion(data, isEOF);
if (isEOF) {
[bdxQueryExpectation1 fulfill];
}
};
sOTAProviderDelegate.transferEndHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSError * _Nullable error) {
XCTAssertEqualObjects(nodeID, @(kDeviceId1));
XCTAssertEqual(controller, sController);
XCTAssertNil(error);
sOTAProviderDelegate.transferEndHandler = nil;
[bdxEndExpectation1 fulfill];
// BDX transfer with device1 has completed
// Set up the query handler for device2 to return image available at imagePath2
sOTAProviderDelegate.queryImageHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterQueryImageParams * params, QueryImageCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId2));
XCTAssertEqual(controller, sController);
sOTAProviderDelegate.queryImageHandler = nil;
[sOTAProviderDelegate respondAvailableWithDelay:@(0)
uri:imagePath2
updateToken:updateToken2
softwareVersion:kUpdatedSoftwareVersion_5
softwareVersionString:kUpdatedSoftwareVersionString_5
completion:completion];
NSLog(@"OTA queryExpectation3");
[queryExpectation3 fulfill];
};
// Set up the BDX transfer begin, block query and transfer end handlers for device2 so it can go ahead with the BDX transfer
sOTAProviderDelegate.transferBeginHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
NSString * fileDesignator, NSNumber * offset, MTRStatusCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId2));
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(fileDesignator, imagePath2);
XCTAssertEqualObjects(offset, @(0));
readHandle = [NSFileHandle fileHandleForReadingAtPath:fileDesignator];
XCTAssertNotNil(readHandle);
NSError * endSeekError;
XCTAssertTrue([readHandle seekToEndReturningOffset:&imageSize error:&endSeekError]);
XCTAssertNil(endSeekError);
sOTAProviderDelegate.transferBeginHandler = nil;
[sOTAProviderDelegate respondSuccess:completion];
lastBlockIndex = UINT32_MAX;
[bdxBeginExpectation2 fulfill];
};
sOTAProviderDelegate.blockQueryHandler = ^(NSNumber * nodeID, MTRDeviceController * controller, NSNumber * blockSize,
NSNumber * blockIndex, NSNumber * bytesToSkip, BlockQueryCompletion completion) {
XCTAssertEqualObjects(nodeID, @(kDeviceId2));
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(blockSize, @(1024)); // Seems to always be 1024.
XCTAssertEqualObjects(blockIndex, @(lastBlockIndex + 1));
XCTAssertEqualObjects(bytesToSkip, @(0)); // Don't expect to see skips here.
// Make sure we actually end up with multiple blocks.
XCTAssertTrue(blockSize.unsignedLongLongValue < imageSize);
XCTAssertNotNil(readHandle);
uint64_t offset = blockSize.unsignedLongLongValue * blockIndex.unsignedLongLongValue;
NSError * seekError = nil;
[readHandle seekToOffset:offset error:&seekError];
XCTAssertNil(seekError);
NSError * readError = nil;
NSData * data = [readHandle readDataUpToLength:blockSize.unsignedLongValue error:&readError];
XCTAssertNil(readError);
XCTAssertNotNil(data);
BOOL isEOF = offset + blockSize.unsignedLongValue >= imageSize;
++lastBlockIndex;
if (isEOF) {
sOTAProviderDelegate.blockQueryHandler = nil;
}
completion(data, isEOF);
if (isEOF) {
[bdxQueryExpectation2 fulfill];
}
};
sOTAProviderDelegate.transferEndHandler
= ^(NSNumber * nodeID, MTRDeviceController * controller, NSError * _Nullable error) {
XCTAssertEqualObjects(nodeID, @(kDeviceId2));
XCTAssertEqual(controller, sController);
XCTAssertNil(error);
sOTAProviderDelegate.transferEndHandler = nil;
[bdxEndExpectation2 fulfill];
};
};
// Flags to track if the applyUpdateRequest from both device1 and device2 has been handled.
__block bool device1HasHandledApplyUpdateRequest = false;
__block bool device2HasHandledApplyUpdateRequest = false;
// Flags to track if device1 and device have notified that the update has been applied.
__block bool device1HasNotifiedUpdateApplied = false;
__block bool device2HasNotifiedUpdateApplied = false;
// Set up the apply update request and update applied handlers for device1 and device2. Use the nodeID to verify which
// device sent the applyUpdateRequest and subsequent notifyUpdateApplied commands.
sOTAProviderDelegate.applyUpdateRequestHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterApplyUpdateRequestParams * params, ApplyUpdateRequestCompletion completion) {
XCTAssertTrue([nodeID isEqualToNumber:@(kDeviceId1)] || [nodeID isEqualToNumber:@(kDeviceId2)]);
bool isDeviceID1 = [nodeID isEqualToNumber:@(kDeviceId1)];
NSData * updateToken = (isDeviceID1) ? updateToken1 : updateToken2;
// Device1 is updated to version 10 and device2 to version 5.
NSNumber * kSoftwareVersion = (isDeviceID1) ? kUpdatedSoftwareVersion_10 : kUpdatedSoftwareVersion_5;
NSString * otaImageFilePath = (isDeviceID1) ? otaRawImagePath1 : otaRawImagePath2;
NSString * otaDownloadedFilePath = (isDeviceID1) ? runner1.downloadFilePath : runner2.downloadFilePath;
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(params.updateToken, updateToken);
XCTAssertEqualObjects(params.newVersion, kSoftwareVersion);
XCTAssertTrue([[NSFileManager defaultManager] contentsEqualAtPath:otaImageFilePath andPath:otaDownloadedFilePath]);
[sOTAProviderDelegate respondToApplyUpdateRequestWithAction:MTROTASoftwareUpdateProviderApplyUpdateActionProceed
completion:completion];
if (isDeviceID1) {
device1HasHandledApplyUpdateRequest = true;
[applyUpdateRequestExpectation1 fulfill];
} else {
device2HasHandledApplyUpdateRequest = true;
[applyUpdateRequestExpectation2 fulfill];
}
// If the applyUpdateRequest from both device1 and device2 has been handled, reset the
// applyUpdateRequestHandler to nil
if (device1HasHandledApplyUpdateRequest && device2HasHandledApplyUpdateRequest) {
sOTAProviderDelegate.applyUpdateRequestHandler = nil;
}
};
sOTAProviderDelegate.notifyUpdateAppliedHandler = ^(NSNumber * nodeID, MTRDeviceController * controller,
MTROTASoftwareUpdateProviderClusterNotifyUpdateAppliedParams * params, MTRStatusCompletion completion) {
XCTAssertTrue([nodeID isEqualToNumber:@(kDeviceId1)] || [nodeID isEqualToNumber:@(kDeviceId2)]);
bool isDeviceID1 = [nodeID isEqualToNumber:@(kDeviceId1)];
NSData * updateToken = (isDeviceID1) ? updateToken1 : updateToken2;
// Device1 is updated to version 10 and device2 to version 5.
NSNumber * kSoftwareVersion = (isDeviceID1) ? kUpdatedSoftwareVersion_10 : kUpdatedSoftwareVersion_5;
XCTAssertEqual(controller, sController);
XCTAssertEqualObjects(params.updateToken, updateToken);
XCTAssertEqualObjects(params.softwareVersion, kSoftwareVersion);
[sOTAProviderDelegate respondSuccess:completion];
if (isDeviceID1) {
device1HasNotifiedUpdateApplied = true;
[notifyUpdateAppliedExpectation1 fulfill];
} else {
device2HasNotifiedUpdateApplied = true;
[notifyUpdateAppliedExpectation2 fulfill];
}
// If both device1 and device2 have notified that the update has been applied, reset the
// notifyUpdateAppliedHandler to nil
if (device1HasNotifiedUpdateApplied && device2HasNotifiedUpdateApplied) {
sOTAProviderDelegate.notifyUpdateAppliedHandler = nil;
}
};
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation1 = [self announceProviderToDevice:device1];
// Make sure we get our callbacks in order for both device1 and device2. Since we do not
// send image available to device2 until BDX for device1 has ended, queryExpectation3 must follow
// bdxEndExpectation1.
//
// Give it a bit more time, because we want to allow time for the BDX downloads.
[self waitForExpectations:@[
queryExpectation1, bdxBeginExpectation1, bdxQueryExpectation1, bdxEndExpectation1, queryExpectation3, bdxBeginExpectation2,
bdxQueryExpectation2, bdxEndExpectation2
]
timeout:(kTimeoutWithUpdateInSeconds) enforceOrder:YES];
// Make sure we get our query expectation for device2 fulfilled when we send busy for device2.
[self waitForExpectations:@[ queryExpectation2 ] timeout:(kTimeoutInSeconds)];
// Nothing really defines the ordering of bdxEndExpectation and
// applyUpdateRequestExpectation with respect to each other.
[self waitForExpectations:@[
applyUpdateRequestExpectation1, notifyUpdateAppliedExpectation1, applyUpdateRequestExpectation2,
notifyUpdateAppliedExpectation2
]
timeout:kTimeoutInSeconds
enforceOrder:NO];
// Nothing defines the ordering of announceResponseExpectation with respect
// to _any_ of the above expectations.
[self waitForExpectations:@[ announceResponseExpectation1, announceResponseExpectation2 ] timeout:kTimeoutInSeconds];
}
- (void)test007_DoBDXTransferIncrementalOtaUpdate
{
// In this test, we test incremental OTA update with device3. First we update device3
// to version 5 using image at imagePath1. Once device3 updates and reboots, we update
// it to version 10 using image at imagePath2.
//
// 1) We announce ourselves to device3.
// 2) When device3 queries, we return image available at imagePath1 with version number 5.
// 3) We set the BDX begin and end handlers for device3 and device3 starts the BDX transfer.
// 4) Device3 completes the BDX transfer
// 5) Device3 applies the update and reboots with the new image with version number 5
// 6) We announce ourselves to device 3 again.
// 7) When device3 queries again, we return image available at imagePath2 with version number 10.
// 8) We set the BDX begin and end handlers for device3 and device3 starts the BDX transfer.
// 4) Device3 completes the BDX transfer
// 5) Device3 applies the update and reboots with the new image with version number 10
NSString * otaRawImagePath1 = [self createRawImageWithVersion:kUpdatedSoftwareVersion_5];
NSString * otaRawImagePath2 = [self createRawImageWithVersion:kUpdatedSoftwareVersion_10];
// Check whether the ota raw image exists at otaRawImagePath1 and otaRawImagePath2
XCTAssertTrue([[NSFileManager defaultManager] fileExistsAtPath:otaRawImagePath1]);
XCTAssertTrue([[NSFileManager defaultManager] fileExistsAtPath:otaRawImagePath2]);
__auto_type * runner = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload3 testcase:self];
__auto_type * device = [runner commissionWithNodeID:@(kDeviceId3)];
__auto_type * checker =
[[MTROTAProviderTransferChecker alloc] initWithRawImagePath:otaRawImagePath1
otaImageDownloadFilePath:runner.downloadFilePath
nodeID:@(kDeviceId3)
softwareVersion:kUpdatedSoftwareVersion_5
softwareVersionString:kUpdatedSoftwareVersionString_5
applyUpdateAction:MTROTASoftwareUpdateProviderApplyUpdateActionProceed
testcase:self];
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation = [self announceProviderToDevice:device];
// Make sure we get our callbacks in order. Give it a bit more time, because
// we want to allow time for the BDX download.
[self waitForExpectations:@[
checker.queryExpectation, checker.bdxBeginExpectation, checker.bdxQueryExpectation, checker.bdxEndExpectation
]
timeout:(kTimeoutWithUpdateInSeconds) enforceOrder:YES];
// Nothing really defines the ordering of bdxEndExpectation and
// applyUpdateRequestExpectation with respect to each other.
[self waitForExpectations:@[ checker.applyUpdateRequestExpectation, checker.notifyUpdateAppliedExpectation ]
timeout:kTimeoutInSeconds
enforceOrder:YES];
// Nothing defines the ordering of announceResponseExpectation with respect
// to _any_ of the above expectations.
[self waitForExpectations:@[ announceResponseExpectation ] timeout:kTimeoutInSeconds];
// Provide an incremental update and makes sure the app is updated to the new version
__auto_type * checker1 =
[[MTROTAProviderTransferChecker alloc] initWithRawImagePath:otaRawImagePath2
otaImageDownloadFilePath:runner.downloadFilePath
nodeID:@(kDeviceId3)
softwareVersion:kUpdatedSoftwareVersion_10
softwareVersionString:kUpdatedSoftwareVersionString_10
applyUpdateAction:MTROTASoftwareUpdateProviderApplyUpdateActionProceed
testcase:self];
// Advertise ourselves as an OTA provider.
XCTestExpectation * announceResponseExpectation1 = [self announceProviderToDevice:device];
// Make sure we get our callbacks in order. Give it a bit more time, because
// we want to allow time for the BDX download.
[self waitForExpectations:@[
checker1.queryExpectation, checker1.bdxBeginExpectation, checker1.bdxQueryExpectation, checker1.bdxEndExpectation
]
timeout:(kTimeoutWithUpdateInSeconds) enforceOrder:YES];
// Nothing really defines the ordering of bdxEndExpectation and
// applyUpdateRequestExpectation with respect to each other.
[self waitForExpectations:@[ checker1.applyUpdateRequestExpectation, checker1.notifyUpdateAppliedExpectation ]
timeout:kTimeoutInSeconds
enforceOrder:YES];
// Nothing defines the ordering of announceResponseExpectation with respect
// to _any_ of the above expectations.
[self waitForExpectations:@[ announceResponseExpectation1 ] timeout:kTimeoutInSeconds];
}
#endif // ENABLE_REAL_OTA_UPDATE_TESTS
- (void)test008_TestWriteDefaultOTAProviders
{
__auto_type * runner = [[MTROTARequestorAppRunner alloc] initWithPayload:kOnboardingPayload1 testcase:self];
MTRDevice * device = [runner commissionWithNodeID:@(kDeviceId1)];
dispatch_queue_t queue = dispatch_get_main_queue();
__auto_type dataValue = ^(uint16_t endpoint) {
return @{
MTRTypeKey : MTRArrayValueType,
MTRValueKey : @[
@{
MTRDataKey : @ {
MTRTypeKey : MTRStructureValueType,
MTRValueKey : @[
@{
MTRContextTagKey : @(1),
MTRDataKey : @ {
MTRTypeKey : MTRUnsignedIntegerValueType,
MTRValueKey : @(kDeviceId1),
},
},
@{
MTRContextTagKey : @(2),
MTRDataKey : @ {
MTRTypeKey : MTRUnsignedIntegerValueType,
MTRValueKey : @(endpoint),
},
},
],
},
},
],
};
};
{
// Test with MTRBaseDevice first.
MTRBaseDevice * baseDevice = [MTRBaseDevice deviceWithNodeID:device.nodeID
controller:device.deviceController];
__auto_type * cluster = [[MTRBaseClusterOTASoftwareUpdateRequestor alloc] initWithDevice:baseDevice
endpointID:@(0)
queue:queue];
__auto_type * providerLocation = [[MTROTASoftwareUpdateRequestorClusterProviderLocation alloc] init];
providerLocation.providerNodeID = @(kDeviceId1);
providerLocation.endpoint = @(0);
__auto_type * value = @[ providerLocation ];
__auto_type * writeBaseClusterExpectation = [self expectationWithDescription:@"Write succeeded via MTRBaseCluster"];
[cluster writeAttributeDefaultOTAProvidersWithValue:value
completion:^(NSError * _Nullable error) {
XCTAssertNil(error);
[writeBaseClusterExpectation fulfill];
}];
[self waitForExpectations:@[ writeBaseClusterExpectation ] timeout:kTimeoutInSeconds];
__auto_type * writeBaseDeviceExpectation = [self expectationWithDescription:@"Write succeeded via MTRBaseDevice"];
[baseDevice writeAttributeWithEndpointID:@(0)
clusterID:@(MTRClusterIDTypeOTASoftwareUpdateRequestorID)
attributeID:@(MTRAttributeIDTypeClusterOTASoftwareUpdateRequestorAttributeDefaultOTAProvidersID)
value:dataValue(0)
timedWriteTimeout:nil
queue:queue
completion:^(NSArray<NSDictionary<NSString *, id> *> * _Nullable values, NSError * _Nullable error) {
XCTAssertNil(error);
XCTAssertNotNil(values);
XCTAssertEqual(values.count, 1);
for (NSDictionary<NSString *, id> * value in values) {
XCTAssertNil(value[MTRErrorKey]);
}
[writeBaseDeviceExpectation fulfill];
}];
[self waitForExpectations:@[ writeBaseDeviceExpectation ] timeout:kTimeoutInSeconds];
}
{
// Now test with MTRDevice
__auto_type * delegate = [[MTRDeviceTestDelegate alloc] init];
// Make sure we don't have expected value notifications confusing our
// attribute reports.
delegate.skipExpectedValuesForWrite = YES;
XCTestExpectation * gotReportsExpectation = [self expectationWithDescription:@"Subscription established"];
delegate.onReportEnd = ^() {
[gotReportsExpectation fulfill];
};
[device setDelegate:delegate queue:queue];
[self waitForExpectations:@[ gotReportsExpectation ] timeout:60];
delegate.onReportEnd = nil;
__auto_type * expectedAttributePath = [MTRAttributePath attributePathWithEndpointID:@(0)
clusterID:@(MTRClusterIDTypeOTASoftwareUpdateRequestorID)
attributeID:@(MTRAttributeIDTypeClusterOTASoftwareUpdateRequestorAttributeDefaultOTAProvidersID)];
__block __auto_type * expectedValue = dataValue(1);
__block __auto_type * writeExpectation = [self expectationWithDescription:@"Write succeeded via MTRCluster"];
delegate.onAttributeDataReceived = ^(NSArray<NSDictionary<NSString *, id> *> * data) {
XCTAssertNotNil(data);
XCTAssertEqual(data.count, 1);
NSDictionary<NSString *, id> * item = data[0];
XCTAssertNil(item[MTRErrorKey]);
MTRAttributePath * path = item[MTRAttributePathKey];
XCTAssertNotNil(path);
XCTAssertEqualObjects(path, expectedAttributePath);
NSDictionary<NSString *, id> * receivedValue = item[MTRDataKey];
// We can't use XCTAssertEqualObjects to compare receivedValue to
// expectedValue here, because receivedValue has a DataVersion
// that's missing from expectedValue, and the struct in it has an
// extra FabricIndex field.
XCTAssertEqualObjects(receivedValue[MTRTypeKey], MTRArrayValueType);
NSArray * receivedArray = receivedValue[MTRValueKey];
NSArray * expectedArray = expectedValue[MTRValueKey];
XCTAssertEqual(receivedArray.count, expectedArray.count);
for (NSUInteger i = 0; i < receivedArray.count; ++i) {
NSDictionary * receivedItem = receivedArray[i][MTRDataKey];
NSDictionary * expectedItem = expectedArray[i][MTRDataKey];
XCTAssertEqual(receivedItem[MTRTypeKey], MTRStructureValueType);
XCTAssertEqual(expectedItem[MTRTypeKey], MTRStructureValueType);
NSArray * receivedFields = receivedItem[MTRValueKey];
NSArray * expectedFields = expectedItem[MTRValueKey];
// Account for the extra FabricIndex.
XCTAssertEqual(receivedFields.count, expectedFields.count + 1);
for (NSUInteger j = 0; j < expectedFields.count; ++j) {
XCTAssertEqualObjects(receivedFields[j], expectedFields[j]);
}
}
[writeExpectation fulfill];
};
__auto_type * cluster = [[MTRClusterOTASoftwareUpdateRequestor alloc] initWithDevice:device
endpointID:@(0)
queue:queue];
[cluster writeAttributeDefaultOTAProvidersWithValue:expectedValue
expectedValueInterval:@(0)];
[self waitForExpectations:@[ writeExpectation ] timeout:kTimeoutInSeconds];
expectedValue = dataValue(2);
writeExpectation = [self expectationWithDescription:@"Write succeeded via MTRDevice"];
[device writeAttributeWithEndpointID:@(0)
clusterID:@(MTRClusterIDTypeOTASoftwareUpdateRequestorID)
attributeID:@(MTRAttributeIDTypeClusterOTASoftwareUpdateRequestorAttributeDefaultOTAProvidersID)
value:expectedValue
expectedValueInterval:@(0)
timedWriteTimeout:nil];
[self waitForExpectations:@[ writeExpectation ] timeout:kTimeoutInSeconds];
}
}
- (void)test999_TearDown
{
[[self class] shutdownStack];
}
@end
#else // ENABLE_OTA_TESTS
@interface MTROTAProviderTests : XCTestCase
@end
@implementation MTROTAProviderTests
@end
#endif // ENABLE_OTA_TESTS