public async Task TryConnectAsync_NoMuxer_ReturnsNull_Async()
{
var client = new Mock <MuxerClient>();
client.CallBase = true;
var device = new MuxerDevice();
client.Setup(c => c.TryConnectToMuxerAsync(default)).ReturnsAsync((MuxerProtocol)null);
public void ToString_ReturnsUdid()
{
var device = new MuxerDevice()
{
Udid = "abc",
};
Assert.Equal("abc", device.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="PairingRecordProvisionerTests"/> class.
/// </summary>
public PairingRecordProvisionerTests()
{
this.pairingWorker = new Mock <PairingWorker>(MockBehavior.Strict);
this.kubernetesPairingRecordStore = new Mock <KubernetesPairingRecordStore>(MockBehavior.Strict);
this.muxerClient = new Mock <MuxerClient>(MockBehavior.Strict);
this.lockdownClient = new Mock <LockdownClient>(MockBehavior.Strict);
this.device = new MuxerDevice()
{
Udid = Udid
};
this.muxerClient.Setup(m => m.ListDevicesAsync(default)).ReturnsAsync(new Collection <MuxerDevice>()
public async Task ProvisionAsync_AlreadyMounted_DoesNothing_Async()
{
var store = new Mock <DeveloperDiskStore>(MockBehavior.Strict);
var provider = new Mock <DeviceServiceProvider>(MockBehavior.Strict);
var device = new MuxerDevice();
var scope = new Mock <DeviceServiceScope>(MockBehavior.Strict);
provider.Setup(p => p.CreateDeviceScopeAsync(device, default)).ReturnsAsync(scope.Object);
var lockdown = new Mock <LockdownClient>(MockBehavior.Strict);
var mounter = new Mock <MobileImageMounterClient>(MockBehavior.Strict);
scope.Setup(s => s.StartServiceAsync <LockdownClient>(default)).ReturnsAsync(lockdown.Object);
/// <summary>
/// Initializes a new instance of the <see cref="PairingWorkerTests"/> class.
/// </summary>
public PairingWorkerTests()
{
this.muxer = new Mock <MuxerClient>(MockBehavior.Strict);
this.notificationProxyClient = new Mock <NotificationProxyClient>(MockBehavior.Strict);
this.lockdown = new Mock <LockdownClient>(MockBehavior.Strict);
this.device = new MuxerDevice()
{
Udid = "my-udid"
};
this.pairingRecordGenerator = new Mock <PairingRecordGenerator>(MockBehavior.Strict);
var lockdownFactory = new Mock <ClientFactory <LockdownClient> >(MockBehavior.Strict);
lockdownFactory.Setup(f => f.CreateAsync(default)).ReturnsAsync(this.lockdown.Object);
/// <summary>
/// Asynchronously create a device scope, which can be used to interact with services running on the iOS device.
/// </summary>
/// <param name="device">
/// The device to which to connect.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> which can be used to cancel the asynchronous operation.
/// </param>
/// <returns>
/// A <see cref="Task"/> which represents the asynchronous operation, and returns a <see cref="IServiceScope"/>
/// from which device services (such as lockdown service clients) can be sourced.
/// </returns>
public virtual async Task <DeviceServiceScope> CreateDeviceScopeAsync(MuxerDevice device, CancellationToken cancellationToken)
{
Requires.NotNull(device, nameof(device));
var muxer = this.provider.GetRequiredService <MuxerClient>();
var scope = this.provider.CreateScope();
var context = scope.ServiceProvider.GetRequiredService <DeviceContext>();
context.Device = device;
context.PairingRecord = await muxer.ReadPairingRecordAsync(context.Device.Udid, cancellationToken).ConfigureAwait(false);
return(new DeviceServiceScope(scope));
}
/// <summary>
/// Asynchronously mounts the developer disk on the device.
/// </summary>
/// <param name="device">
/// The device on which to mount the developer disk.
/// </param>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken"/> which can be used to cancel the asynchronous operation.
/// </param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation. The task returns a value indicating whether the developer disk
/// is mounted on the device or not.
/// </returns>
public virtual async Task <bool> ProvisionDeveloperDiskAsync(MuxerDevice device, CancellationToken cancellationToken)
{
using (var scope = await this.serviceProvider.CreateDeviceScopeAsync(device, cancellationToken).ConfigureAwait(false))
await using (var lockdown = await scope.StartServiceAsync <LockdownClient>(cancellationToken).ConfigureAwait(false))
await using (var imageMounterClient = await scope.StartServiceAsync <MobileImageMounterClient>(cancellationToken).ConfigureAwait(false))
{
var developerDiskStatus = await imageMounterClient.LookupImageAsync("Developer", cancellationToken).ConfigureAwait(false);
// The disk is already mounted.
if (developerDiskStatus.ImageSignature.Count > 0)
{
var signature = developerDiskStatus.ImageSignature.Count > 0 ? Convert.ToBase64String(developerDiskStatus.ImageSignature[0]) : string.Empty;
this.logger.LogWarning("A developer disk has already been mounted on device {udid}: {signature}", device.Udid, signature);
return(true);
}
// Fetch the disk from the store
var versionString = await lockdown.GetValueAsync("ProductVersion", cancellationToken).ConfigureAwait(false);
var version = Version.Parse(versionString);
var developerDisk = await this.developerDiskStore.GetAsync(version, cancellationToken).ConfigureAwait(false);
if (developerDisk == null && version.Build >= 0)
{
var reducedVersion = new Version(version.Major, version.Minor);
this.logger.LogWarning("Could not found the developer disk for version {version}. Attempting to find the developer disk for version {reducedVersion}", version, reducedVersion);
developerDisk = await this.developerDiskStore.GetAsync(reducedVersion, cancellationToken).ConfigureAwait(false);
}
if (developerDisk == null)
{
this.logger.LogWarning("Could not mount the developer disk on device {udid} because no developer disk is available", device.Udid);
return(false);
}
await imageMounterClient.UploadImageAsync(developerDisk.Image, "Developer", developerDisk.Signature, cancellationToken).ConfigureAwait(false);
await imageMounterClient.MountImageAsync(developerDisk.Signature, "Developer", cancellationToken).ConfigureAwait(false);
this.logger.LogInformation("Mounted the developer disk on device {udid}", device.Udid);
return(true);
}
}
public async Task Connect_Works_Async()
{
// Sample traffic from https://www.theiphonewiki.com/wiki/Usbmux ("lockdownd protocol")
var muxer = new Mock <MuxerClient>();
var device = new MuxerDevice();
using (var traceStream = new TraceStream("Lockdown/connect-device.bin", "Lockdown/connect-host.bin"))
{
muxer
.Setup(m => m.ConnectAsync(device, 0xF27E, default))
.ReturnsAsync(traceStream);
var factory = new LockdownClientFactory(muxer.Object, new DeviceContext()
{
Device = device
}, NullLogger <LockdownClient> .Instance);
await using (await factory.CreateAsync(default))
