public void Test_Run( )
{
using (var mock = GetMock( ))
{
ImportRunWorker worker = mock.Create <ImportRunWorker>( );
var importRun = GetImportRun(mock);
Field field = new StringField( ).AsWritable <Field>( );
field.Name = "Field1";
EntityType type = new EntityType( );
type.Fields.Add(field);
ApiFieldMapping fieldMapping = new ApiFieldMapping( );
fieldMapping.MappedField = field;
fieldMapping.Name = "NotAValidExcelColumnReference";
ApiResourceMapping mapping = importRun.ImportConfigUsed.ImportConfigMapping;
mapping.ResourceMemberMappings.Add(fieldMapping.As <ApiMemberMapping>( ));
mapping.MappedType = type;
importRun.Save( );
worker.StartImport(MockRunId);
Assert.That(importRun.ImportRunStatus_Enum, Is.EqualTo(WorkflowRunState_Enumeration.WorkflowRunCompleted));
Assert.That(importRun.ImportRecordsSucceeded, Is.EqualTo(4));
Assert.That(importRun.ImportRecordsTotal, Is.EqualTo(4));
Assert.That(importRun.ImportRecordsFailed, Is.EqualTo(0));
Assert.That(importRun.ImportRunFinished, Is.Not.Null);
}
}
/// <summary>
/// Create the member processor callbacks.
/// </summary>
private List <MemberProcessor> CreateMemberProcessors(ApiResourceMapping mapping, ReaderToEntityAdapterSettings settings)
{
var memberProcessors = new List <MemberProcessor>( );
// Process mapped members
// Note: we intentionally ignore unrecognised members.
foreach (ApiMemberMapping memberMappings in mapping.ResourceMemberMappings)
{
MemberProcessor memberProcessor;
// Fill field
ApiFieldMapping fieldMapping = memberMappings.As <ApiFieldMapping>( );
if (fieldMapping != null)
{
memberProcessor = CreateFieldProcessor(fieldMapping, settings);
memberProcessors.Add(memberProcessor);
continue;
}
// Fill relationship
ApiRelationshipMapping relMapping = memberMappings.As <ApiRelationshipMapping>( );
if (relMapping != null)
{
memberProcessor = CreateRelationshipProcessor(relMapping, settings);
memberProcessors.Add(memberProcessor);
continue;
}
// Assert false
throw new InvalidOperationException("Unknown member mapping");
}
return(memberProcessors);
}
public static ApiFieldMapping CreateApiFieldMapping(ApiResourceMapping resourceMapping, EntityRef field, string memberName)
{
Field fieldResource = Entity.Get <Field>(field);
ApiFieldMapping mapping = new ApiFieldMapping( );
mapping.MappedField = fieldResource;
mapping.Name = memberName;
resourceMapping.ResourceMemberMappings.Add(mapping.As <ApiMemberMapping>( ));
return(mapping);
}
/// <summary>
/// Get all the mapping columns from selected entity Type.
/// </summary>
public static void AddAllFields(ImportConfig importConfig) // List<ColumnInfo> mappingColumnCollection, EntityType type, DbDataTable sampleDataTable )
{
EntityType type = importConfig.ImportConfigMapping.MappedType;
var allFields = EntityTypeHelper.GetAllFields(type);
foreach (Field field in allFields)
{
if (field.Name == "Alias")
{
continue;
}
ApiFieldMapping fieldMapping = new ApiFieldMapping( );
fieldMapping.Name = field.Name;
fieldMapping.MappedField = field;
}
}
public void Test_MandatoryField(string mandatoryDefinedOn, string data)
{
// Create JSON
string jsonMember = "member";
string jsonData = data.Replace("'", "\"");
string json = "{\"" + jsonMember + "\":" + jsonData + "}";
if (data == "'unprovided'")
{
json = json.Replace(jsonMember, "somethingelse");
}
// Create a type mapping
EntityType entityTypeResource = new EntityType();
ApiResourceMapping typeMapping = new ApiResourceMapping();
typeMapping.MappedType = entityTypeResource;
// Create a member mapping
StringField fieldResource = new StringField();
ApiFieldMapping fieldMapping = new ApiFieldMapping();
fieldMapping.MappedField = fieldResource.As <Field>();
fieldMapping.Name = jsonMember;
typeMapping.ResourceMemberMappings.Add(fieldMapping.As <ApiMemberMapping>());
if (mandatoryDefinedOn == "Mapping")
{
fieldMapping.ApiMemberIsRequired = true;
}
if (mandatoryDefinedOn == "Schema")
{
fieldResource.IsRequired = true;
}
entityTypeResource.Save( );
// Fill entity
if (data == "'provided'")
{
IEntity entity = RunTest(json, typeMapping);
}
else
{
Assert.Throws <ConnectorRequestException>(() => RunTest(json, typeMapping), "E1010 '" + jsonMember + "' value is required.");
}
}
/// <summary>
/// Get all the mapping columns from selected entity Type.
/// </summary>
private static void AddAllFields(ImportConfig importConfig, SampleTable sample) // List<ColumnInfo> mappingColumnCollection, EntityType type, DbDataTable sampleDataTable )
{
EntityType type = importConfig.ImportConfigMapping.MappedType;
var allFields = EntityTypeHelper.GetAllFields(type);
foreach (Field field in allFields)
{
if (field.Name == "Alias")
{
continue;
}
SampleColumn column = sample.Columns.FirstOrDefault(col => col.Name == field.Name);
if (column == null)
{
continue;
}
ApiFieldMapping fieldMapping = new ApiFieldMapping( );
fieldMapping.Name = column.ColumnName;
fieldMapping.MappedField = field;
importConfig.ImportConfigMapping.ResourceMemberMappings.Add(fieldMapping.As <ApiMemberMapping>( ));
}
}
public void Test_Failure_NoRecordsSucceeded( )
{
using (var mock = GetMock( ))
{
// Create an int field and write string data to it.
Field field = new IntField( ).AsWritable <Field>( );
field.Name = "Field2";
field.IsRequired = true;
ApiFieldMapping mappedField = new ApiFieldMapping( );
mappedField.MappedField = field;
mappedField.Name = "A"; // text column on Test3 sheet
var importConfig = GetImportRun(mock).ImportConfigUsed;
importConfig.ImportConfigMapping.MappingSourceReference = "Test3";
importConfig.ImportConfigMapping.ImportDataRow = 16; // only ask for two rows
var mapping = importConfig.ImportConfigMapping;
mapping.MappedType.Fields.Add(field);
mapping.ResourceMemberMappings.Clear( );
mapping.ResourceMemberMappings.Add(mappedField.As <ApiMemberMapping>( ));
GetImportRun(mock).Save( );
RunAndAssertFailure(mock, "No records were successfully imported.\r\nRow 16: Value for 'Field2' was formatted incorrectly.\r\nRow 17: Value for 'Field2' was formatted incorrectly.");
}
}
public void Setup( )
{
// Getting Forbidden? Or ConnectorConfigException?
// Maybe there's duplicate copies of these objects in the DB.
// Define key and user
using (new TenantAdministratorContext(TenantName))
{
// Define schema
type = new EntityType( );
type.Inherits.Add(UserResource.UserResource_Type);
type.Name = "Test type " + Guid.NewGuid( );
type.Save( );
type2 = new EntityType();
type2.Inherits.Add(UserResource.UserResource_Type);
type2.Name = "Test type2 " + Guid.NewGuid();
type2.Save();
stringField = new StringField( );
stringField.Name = "Field 1";
stringField.FieldIsOnType = type;
stringField.Save( );
lookup = new Relationship();
lookup.Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne;
lookup.FromType = type;
lookup.ToType = type2;
// Define API
mapping = new ApiResourceMapping( );
mapping.Name = "Test mapping " + Guid.NewGuid( );;
mapping.MappedType = type;
mapping.Save( );
lookupMapping = new ApiRelationshipMapping();
lookupMapping.Name = "lookup1";
lookupMapping.MappedRelationship = lookup;
lookupMapping.MemberForResourceMapping = mapping;
lookupMapping.Save();
fieldMapping = new ApiFieldMapping( );
fieldMapping.Name = "field1";
fieldMapping.MappedField = stringField.As <Field>( );
fieldMapping.MemberForResourceMapping = mapping;
fieldMapping.Save( );
endpoint = new ApiResourceEndpoint( );
endpoint.Name = "Test endpoint " + Guid.NewGuid( );
endpoint.ApiEndpointAddress = EndpointAddress;
endpoint.EndpointResourceMapping = mapping;
endpoint.ApiEndpointEnabled = true;
endpoint.EndpointCanCreate = true;
endpoint.EndpointCanDelete = true;
endpoint.EndpointCanUpdate = true;
endpoint.Save( );
api = new Api( );
api.Name = "Test API " + Guid.NewGuid( );;
api.ApiAddress = ApiAddress;
api.ApiEnabled = true;
api.ApiEndpoints.Add(endpoint.As <ApiEndpoint>( ));
api.Save( );
// Define access
userAccount = new UserAccount( );
userAccount.Name = "Test user " + Guid.NewGuid( );
userAccount.AccountStatus_Enum = UserAccountStatusEnum_Enumeration.Active;
userAccount.Password = "******";
userAccount.Save( );
key = new ApiKey( );
key.Name = ApiKey;
key.ApiKeyUserAccount = userAccount;
key.ApiKeyEnabled = true;
key.KeyForApis.Add(api);
key.Save( );
updateInstance = Entity.Create(type).AsWritable <Resource>( );
updateInstance.Name = updateInstanceName = "ResourceToUpdate" + Guid.NewGuid( );
updateInstance.Description = updateInstanceDesc = "ResourceToUpdate" + Guid.NewGuid( );
updateInstance.Save( );
updateInstanceGuid = updateInstance.UpgradeId;
IAccessRuleFactory accessControlHelper = new AccessRuleFactory( );
accessRule = accessControlHelper.AddAllowCreate(userAccount.As <Subject>( ), type.As <SecurableEntity>( ));
accessRule = accessControlHelper.AddAllowByQuery(userAccount.As <Subject>( ), type.As <SecurableEntity>( ), new[] { Permissions.Read, Permissions.Modify, Permissions.Delete }, TestQueries.Entities(type).ToReport( ));
}
cleanup = new List <IEntity> {
userAccount, key, api, type, mapping, endpoint, fieldMapping, stringField, accessRule, updateInstance
};
}
/// <summary>
/// Create a delegate that will copy a single field member from a reader to an entity.
/// </summary>
private MemberProcessor CreateFieldProcessor(ApiFieldMapping mapping, ReaderToEntityAdapterSettings settings)
{
// Get field definition
Field field = mapping.MappedField;
if (field == null)
{
throw new ConnectorConfigException(string.Format(Messages.FieldMappingHasNoField, mapping.Name));
}
bool memberRequired = mapping.ApiMemberIsRequired == true;
bool mandatory = field.IsRequired == true || memberRequired;
bool isBool = field.Is <BoolField>( );
// Get mapping name
string memberName = mapping.Name;
string reportingName = GetReportingName(memberName, field.Name, settings);
// Get value-getter
Func <IObjectReader, object> getter = CreateValueGetter(memberName, field, settings);
// Create processor that copies value.
Action <IObjectReader, IEntity, IImportReporter> processor = (reader, entity, reporter) =>
{
// Handle missing fields
bool hasKey = reader.HasKey(memberName);
// Get value
object value = null;
try
{
if (hasKey)
{
value = getter(reader);
}
else if (isBool && !memberRequired)
{
value = false;
}
}
catch (FormatException)
{
reporter.ReportError(reader, string.Format(Messages.PropertyWasFormattedIncorrectly, reportingName));
return;
}
catch (InvalidCastException)
{
reporter.ReportError(reader, string.Format(Messages.PropertyWasFormattedIncorrectly, reportingName));
return;
}
// Handle empty fields
if (mandatory && (value == null || string.Empty.Equals(value)))
{
reporter.ReportError(reader, string.Format(Messages.MandatoryPropertyMissing, reportingName));
return;
}
// Set value
entity.SetField(field, value);
};
return(new MemberProcessor(processor));
}
private void CreateScenarioImpl(string testInstanceName, Func <EntityRef[]> permissionsCallback)
{
// Define key and user
using (new TenantAdministratorContext(TenantName))
{
// Define schema
type = new EntityType( );
type.Inherits.Add(UserResource.UserResource_Type);
type.Name = "Test type " + Guid.NewGuid( );
type.Save( );
type2 = new EntityType( );
type2.Inherits.Add(UserResource.UserResource_Type);
type2.Name = "Test type2 " + Guid.NewGuid( );
type2.Save( );
stringField = new StringField( );
stringField.Name = "Field 1";
stringField.FieldIsOnType = type;
stringField.MaxLength = 50;
stringField.Save( );
lookup = new Relationship( );
lookup.Cardinality_Enum = CardinalityEnum_Enumeration.OneToOne;
lookup.FromType = type;
lookup.ToType = type2;
relationship = new Relationship( );
relationship.Cardinality_Enum = CardinalityEnum_Enumeration.ManyToMany;
relationship.FromType = type;
relationship.ToType = type2;
// Define API
mapping = new ApiResourceMapping( );
mapping.Name = "Test mapping " + Guid.NewGuid( );;
mapping.MappedType = type;
mapping.Save( );
fieldMapping = new ApiFieldMapping( );
fieldMapping.Name = "field1";
fieldMapping.MappedField = stringField.As <Field>( );
fieldMapping.MemberForResourceMapping = mapping;
fieldMapping.Save( );
lookupMapping = new ApiRelationshipMapping( );
lookupMapping.Name = "lookup1";
lookupMapping.MappedRelationship = lookup;
lookupMapping.MemberForResourceMapping = mapping;
lookupMapping.Save( );
relationshipMapping = new ApiRelationshipMapping( );
relationshipMapping.Name = "rel1";
relationshipMapping.MappedRelationship = relationship;
relationshipMapping.MemberForResourceMapping = mapping;
relationshipMapping.Save( );
endpoint = new ApiResourceEndpoint( );
endpoint.Name = "Test endpoint " + Guid.NewGuid( );;
endpoint.ApiEndpointAddress = EndpointAddress;
endpoint.EndpointResourceMapping = mapping;
endpoint.ApiEndpointEnabled = true;
endpoint.EndpointCanCreate = true;
endpoint.EndpointCanUpdate = true;
endpoint.EndpointCanDelete = true;
endpoint.Save( );
api = new Api( );
api.Name = "Test API " + Guid.NewGuid( );;
api.ApiAddress = ApiAddress;
api.ApiEnabled = true;
api.ApiEndpoints.Add(endpoint.As <ApiEndpoint>( ));
api.Save( );
// Define access
userAccount = new UserAccount( );
userAccount.Name = "Test user " + Guid.NewGuid( );
userAccount.AccountStatus_Enum = UserAccountStatusEnum_Enumeration.Active;
userAccount.Password = "******";
userAccount.Save( );
key = new ApiKey( );
key.Name = ApiKey;
key.ApiKeyUserAccount = userAccount;
key.ApiKeyEnabled = true;
key.KeyForApis.Add(api);
key.Save( );
if (testInstanceName != null)
{
scenarioInstance = Entity.Create(type);
scenarioInstance.SetField("core:name", testInstanceName);
scenarioInstance.Save( );
}
foreignName = "Foreign" + Guid.NewGuid( ).ToString( );
foreignInstance = Entity.Create(type2);
foreignInstance.SetField("core:name", foreignName);
foreignInstance.Save( );
// Grant create
var permissions = permissionsCallback( );
IAccessRuleFactory accessControlHelper = new AccessRuleFactory( );
if (permissions [0] == Permissions.Create)
{
accessControlHelper.AddAllowCreate(userAccount.As <Subject>( ), type.As <SecurableEntity>( ));
}
else if (permissions.Length > 0)
{
accessControlHelper.AddAllowByQuery(userAccount.As <Subject>( ), type.As <SecurableEntity>( ), permissions, TestQueries.Entities(type).ToReport( ));
}
accessControlHelper.AddAllowByQuery(userAccount.As <Subject>( ), type2.As <SecurableEntity>( ), new [] { Permissions.Read, Permissions.Modify }, TestQueries.Entities(type2).ToReport( ));
}
}
