public void LoginsTests()
{
CognitoIdentity.CreateIdentityPool(out poolId, out poolName);
TestCredentials(usePoolRoles: false);
TestCredentials(usePoolRoles: true);
}
public void Cleanup()
{
CognitoIdentity.CleanupIdentityPools();
CleanupCreatedRoles();
if (facebookUser != null)
{
FacebookUtilities.DeleteFacebookUser(facebookUser);
}
using (var sns = new AmazonSimpleNotificationServiceClient())
{
foreach (var topicArn in topicArns)
{
sns.DeleteTopic(topicArn);
}
topicArns.Clear();
if (platformApplicationArn != null)
{
sns.DeletePlatformApplication(new DeletePlatformApplicationRequest
{
PlatformApplicationArn = platformApplicationArn
});
}
}
}
public void IdentityTests()
{
CognitoIdentity.CreateIdentityPool(out poolId, out poolName);
// Add retry logic to handle the eventual consistence of the identity pool getting created
GetIdentityPoolConfigurationResponse config = null;
UtilityMethods.WaitUntilSuccess(() => config = Client.GetIdentityPoolConfiguration(poolId));
Assert.IsNotNull(config);
Assert.AreEqual(poolId, config.IdentityPoolId);
Assert.IsNull(config.PushSync);
var usages = GetAllIdentityPoolUsages();
Assert.IsNotNull(usages);
Assert.AreNotEqual(0, usages.Count);
int usagesCount = usages.Count;
usages = GetAllIdentityPoolUsages();
Assert.IsNotNull(usages);
Assert.AreNotEqual(0, usages.Count);
Assert.AreEqual(usagesCount, usages.Count);
// Eventual consistency for IAM role
UtilityMethods.WaitUntilSuccess(() => TestAuthenticatedClient(usePoolRoles: true));
UtilityMethods.WaitUntilSuccess(() => TestAuthenticatedClient(usePoolRoles: false));
}
public void Cleanup()
{
CognitoIdentity.CleanupIdentityPools();
if (!string.IsNullOrEmpty(roleName))
{
DeleteRole(roleName);
}
}
public void CredentialsTests()
{
CognitoIdentity.CreateIdentityPool(out poolId, out poolName);
var credentials = GetCognitoCredentials(poolId, usePoolRoles: false);
TestCredentials(credentials);
credentials = GetCognitoCredentials(poolId, usePoolRoles: true);
TestCredentials(credentials);
}
public void ConfigsTest()
{
CognitoIdentity.CreateIdentityPool(out poolId, out poolName);
var config = Client.GetIdentityPoolConfiguration(new GetIdentityPoolConfigurationRequest
{
IdentityPoolId = poolId
});
Assert.AreEqual(poolId, config.IdentityPoolId);
Assert.IsNull(config.PushSync);
CreatePlatformApplication();
Client.SetIdentityPoolConfiguration(new SetIdentityPoolConfigurationRequest
{
IdentityPoolId = poolId,
PushSync = new PushSync
{
ApplicationArns = new List <string> {
platformApplicationArn
},
RoleArn = null
}
});
config = Client.GetIdentityPoolConfiguration(new GetIdentityPoolConfigurationRequest
{
IdentityPoolId = poolId
});
Assert.AreEqual(poolId, config.IdentityPoolId);
Assert.IsNotNull(config.PushSync);
Assert.IsNull(config.PushSync.RoleArn);
Assert.IsNotNull(config.PushSync.ApplicationArns);
Assert.AreEqual(1, config.PushSync.ApplicationArns.Count);
Client.SetIdentityPoolConfiguration(new SetIdentityPoolConfigurationRequest
{
IdentityPoolId = poolId,
PushSync = new PushSync
{
//ApplicationArns = new List<string> { platformApplicationArn },
//RoleArn = null
}
});
config = Client.GetIdentityPoolConfiguration(new GetIdentityPoolConfigurationRequest
{
IdentityPoolId = poolId
});
Assert.AreEqual(poolId, config.IdentityPoolId);
Assert.IsNull(config.PushSync);
}
public void EventsTest()
{
CognitoIdentity.CreateIdentityPool(out poolId, out poolName);
var events = Client.GetCognitoEvents(new GetCognitoEventsRequest
{
IdentityPoolId = poolId
}).Events;
Assert.AreEqual(0, events.Count);
string functionName, functionArn, roleName, roleArn;
LambdaTests.CreateLambdaFunction(out functionName, out functionArn, out roleName, out roleArn);
Client.SetCognitoEvents(new SetCognitoEventsRequest
{
IdentityPoolId = poolId,
Events = new Dictionary <string, string>
{
{ "SyncTrigger", functionArn }
}
});
events = Client.GetCognitoEvents(new GetCognitoEventsRequest
{
IdentityPoolId = poolId
}).Events;
Assert.AreEqual(1, events.Count);
Client.SetCognitoEvents(new SetCognitoEventsRequest
{
IdentityPoolId = poolId,
Events = new Dictionary <string, string>
{
{ "SyncTrigger", "" }
}
});
events = Client.GetCognitoEvents(new GetCognitoEventsRequest
{
IdentityPoolId = poolId
}).Events;
Assert.AreEqual(0, events.Count);
}
private void TestCredentials(bool usePoolRoles)
{
int credentialsChanges = 0;
CognitoAWSCredentials credentials;
using (var authenticatedClient = CreateAuthenticatedClient(poolId, usePoolRoles, out credentials))
{
// Log and count identity changes
credentials.IdentityChangedEvent += (sender, args) =>
{
credentialsChanges++;
Console.WriteLine("Identity changed: [{0}] => [{1}]", args.OldIdentityId, args.NewIdentityId);
};
string datasetName = "sample-dataset";
// Test calls using unauthenticated role
TestDataCalls(datasetName, authenticatedClient);
// Configure IdentityPool to support Facebook logins
CognitoIdentity.UpdateIdentityPool(poolId, poolName,
new Dictionary <string, string> {
{ FacebookProvider, FacebookAppId }
});
// Create a Facebook user and supply this information to the credentials
facebookUser = FacebookUtilities.CreateFacebookUser(FacebookAppId, FacebookAppSecret);
var facebookAccessToken = facebookUser.AccessToken;
// Logins was updated, clear the current credentials
credentials.AddLogin(FacebookProvider, facebookAccessToken);
// Test calls using authenticated role
TestDataCalls(datasetName, authenticatedClient);
}
Assert.AreEqual(2, credentialsChanges);
}
public void IdentityTests()
{
CognitoIdentity.CreateIdentityPool(out poolId, out poolName);
var usages = GetAllIdentityPoolUsages();
Assert.IsNotNull(usages);
Assert.AreNotEqual(0, usages.Count);
int usagesCount = usages.Count;
var identityId = CognitoIdentity.CreateIdentity(poolId, poolName);
usages = GetAllIdentityPoolUsages();
Assert.IsNotNull(usages);
Assert.AreNotEqual(0, usages.Count);
Assert.AreEqual(usagesCount, usages.Count);
var datasets = GetAllDatasets(poolId, identityId);
Assert.AreEqual(0, datasets.Count);
string datasetName = "sample-dataset";
var recordsResult = Client.ListRecords(new ListRecordsRequest
{
DatasetName = datasetName,
IdentityPoolId = poolId,
IdentityId = identityId,
MaxResults = 1
});
Assert.IsNotNull(recordsResult);
Assert.AreEqual(0, recordsResult.Count);
Assert.IsFalse(recordsResult.DatasetDeletedAfterRequestedSyncCount);
Assert.IsFalse(recordsResult.DatasetExists);
Assert.AreEqual(0, recordsResult.DatasetSyncCount);
Assert.IsNull(recordsResult.LastModifiedBy);
Assert.AreEqual(0, recordsResult.MergedDatasetNames.Count);
Assert.AreEqual(0, recordsResult.Records.Count);
Assert.IsFalse(string.IsNullOrEmpty(recordsResult.SyncSessionToken));
// Some operations require an authenticated client
using (var authenticatedClient = CreateAuthenticatedClient(poolId, poolName, identityId, out roleName))
{
string key1 = "key1";
var updateRequest = new UpdateRecordsRequest
{
DatasetName = datasetName,
IdentityPoolId = poolId,
IdentityId = identityId,
RecordPatches = new List <RecordPatch>
{
new RecordPatch
{
Op = Operation.Replace,
SyncCount = 0,
Key = key1,
Value = key1
}
},
SyncSessionToken = recordsResult.SyncSessionToken
};
// Add retries in case the identity pool is not ready yet.
List <Record> records = null;
for (int retries = 0; retries < 5 && records == null; retries++)
{
Thread.Sleep(1000 * retries);
try
{
records = authenticatedClient.UpdateRecords(updateRequest).Records;
}
catch (AmazonCognitoSyncException e)
{
if (e.StatusCode == System.Net.HttpStatusCode.Forbidden)
{
continue;
}
throw;
}
}
Assert.AreEqual(1, records.Count);
recordsResult = Client.ListRecords(new ListRecordsRequest
{
DatasetName = datasetName,
IdentityPoolId = poolId,
IdentityId = identityId,
MaxResults = 1
});
Assert.IsNotNull(recordsResult);
Assert.AreEqual(1, recordsResult.Count);
Assert.IsFalse(recordsResult.DatasetDeletedAfterRequestedSyncCount);
Assert.IsTrue(recordsResult.DatasetExists);
Assert.AreEqual(1, recordsResult.DatasetSyncCount);
Assert.AreEqual(0, recordsResult.MergedDatasetNames.Count);
Assert.AreEqual(1, recordsResult.Records.Count);
Assert.IsFalse(string.IsNullOrEmpty(recordsResult.SyncSessionToken));
updateRequest = new UpdateRecordsRequest
{
DatasetName = datasetName,
IdentityPoolId = poolId,
IdentityId = identityId,
RecordPatches = new List <RecordPatch>
{
new RecordPatch
{
Op = Operation.Replace,
SyncCount = 1,
Key = key1,
Value = key1
}
},
SyncSessionToken = recordsResult.SyncSessionToken
};
records = authenticatedClient.UpdateRecords(updateRequest).Records;
var allRecords = GetAllRecords(datasetName, poolId, identityId);
Assert.AreEqual(1, records.Count);
}
var describeRequest = new DescribeDatasetRequest
{
DatasetName = datasetName,
IdentityId = identityId,
IdentityPoolId = poolId
};
var dataset = Client.DescribeDataset(describeRequest).Dataset;
Assert.IsNotNull(dataset);
Assert.AreEqual(datasetName, dataset.DatasetName);
var poolUsage = Client.DescribeIdentityPoolUsage(new DescribeIdentityPoolUsageRequest
{
IdentityPoolId = poolId
}).IdentityPoolUsage;
Assert.IsNotNull(poolUsage.LastModifiedDate);
var identityUsage = Client.DescribeIdentityUsage(new DescribeIdentityUsageRequest
{
IdentityId = identityId,
IdentityPoolId = poolId
}).IdentityUsage;
Assert.IsNotNull(identityUsage);
Assert.AreEqual(identityId, identityUsage.IdentityId);
Assert.AreEqual(poolId, identityUsage.IdentityPoolId);
datasets = GetAllDatasets(poolId, identityId);
Assert.AreEqual(1, datasets.Count);
Client.DeleteDataset(new DeleteDatasetRequest
{
DatasetName = datasetName,
IdentityPoolId = poolId,
IdentityId = identityId
});
datasets = GetAllDatasets(poolId, identityId);
Assert.AreEqual(0, datasets.Count);
AssertExtensions.ExpectException(() => Client.DescribeDataset(describeRequest));
}
public static void ClassCleanup()
{
CognitoIdentity.BaseClean();
BaseClean();
}
public static void ClassCleanup()
{
CognitoIdentity.BaseClean();
BaseClean();
LambdaTests.DeleteCreatedFunctions(LambdaTests.Client);
}
