public async void VerifyExternalLanguageDeleteRequestFailures()
{
ExternalLanguage language = new ExternalLanguage
{
Name = "name"
};
Mock <ExternalLanguageOperations> operations = new Mock <ExternalLanguageOperations>();
operations.Setup(x => x.DeleteLanguage(It.IsAny <IDbConnection>(), language.Name)).Throws(new Exception("Error"));
ExternalLanguageService service = new ExternalLanguageService()
{
ExternalLanguageOperations = operations.Object
};
await VerifyError <ExternalLanguageDeleteResponseParams>(
test : async(requestContext, connectionUrl) =>
{
ExternalLanguageDeleteRequestParams requestParams = new ExternalLanguageDeleteRequestParams
{
OwnerUri = connectionUrl,
LanguageName = language.Name
};
await service.HandleExternalLanguageDeleteRequest(requestParams, requestContext);
return(null);
});
}
public void VerifyCreateLanguageWithLocalFile()
{
using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
{
ExternalLanguageOperations operations = new ExternalLanguageOperations();
ExternalLanguage newLanguage = new ExternalLanguage()
{
Name = "newLang",
Contents = new List <ExternalLanguageContent>()
{
new ExternalLanguageContent
{
IsLocalFile = true,
PathToExtension = queryTempFile.FilePath
}
}
};
Verify(null, (connection, lang, commandMock) =>
{
operations.UpdateLanguage(connection, newLanguage);
commandMock.VerifySet(x => x.CommandText = It.Is <string>(s => s.Contains(ExternalLanguageOperations.CreateScript)));
return(true);
});
}
}
public async void VerifyExternalLanguageDeleteRequest()
{
ExternalLanguage language = new ExternalLanguage
{
Name = "name"
};
Mock <ExternalLanguageOperations> operations = new Mock <ExternalLanguageOperations>();
operations.Setup(x => x.DeleteLanguage(It.IsAny <IDbConnection>(), language.Name));
ExternalLanguageService service = new ExternalLanguageService()
{
ExternalLanguageOperations = operations.Object
};
await VerifyRequst <ExternalLanguageDeleteResponseParams>(
test : async(requestContext, connectionUrl) =>
{
ExternalLanguageDeleteRequestParams requestParams = new ExternalLanguageDeleteRequestParams
{
OwnerUri = connectionUrl,
LanguageName = language.Name
};
await service.HandleExternalLanguageDeleteRequest(requestParams, requestContext);
return(null);
},
verify : (actual =>
{
Assert.NotNull(actual);
}));
}
public void VerifyRemoveContentLanguage()
{
ExternalLanguageOperations operations = new ExternalLanguageOperations();
ExternalLanguage language = new ExternalLanguage()
{
Name = "name",
Contents = new List <ExternalLanguageContent>()
{
new ExternalLanguageContent
{
IsLocalFile = false,
ExtensionFileName = "filepath"
}
}
};
ExternalLanguage newLanguage = new ExternalLanguage()
{
Name = language.Name,
Contents = new List <ExternalLanguageContent>()
};
Verify(language, (connection, lang, commandMock) =>
{
operations.UpdateLanguage(connection, newLanguage);
commandMock.VerifySet(x => x.CommandText = It.Is <string>(
s => s.Contains(ExternalLanguageOperations.AlterScript) &&
s.Contains(ExternalLanguageOperations.RemoveContentScript)));
return(true);
});
}
public void VerifyDeleteLanguageWithInvalidName()
{
ExternalLanguageOperations operations = new ExternalLanguageOperations();
ExternalLanguage language = new ExternalLanguage();
Verify(language, (connection, lang, commandMock) =>
{
Assert.Throws <LanguageExtensibilityException>(() => operations.DeleteLanguage(connection, language.Name));
return(true);
});
}
/// <summary>
/// Returns the status of external languages in a connection
/// </summary>
/// <param name="connection"></param>
/// <param name="languageName"></param>
/// <returns></returns>
private List <ExternalLanguage> GetLanguages(IDbConnection connection, string languageName = null)
{
Dictionary <int, ExternalLanguage> dic = new Dictionary <int, ExternalLanguage>();
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = languageName != null ? GetLanguageScript : GetAllScript;
if (languageName != null)
{
var parameter = command.CreateParameter();
parameter.ParameterName = $"@{LanguageNameParamName}";
parameter.Value = languageName;
command.Parameters.Add(parameter);
}
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
int id = reader.GetInt32(0);
string name = reader.GetString(1);
string createdDate = reader.IsDBNull(2) ? string.Empty : reader.GetDateTime(2).ToString();
string owner = reader.IsDBNull(3) ? string.Empty : reader.GetString(3);
string extentionFileName = reader.IsDBNull(5) ? string.Empty : reader.GetString(5);
string platform = reader.IsDBNull(6) ? string.Empty : reader.GetString(6);
string parameters = reader.IsDBNull(7) ? string.Empty : reader.GetString(7);
string envVariables = reader.IsDBNull(8) ? string.Empty : reader.GetString(8);
if (!dic.ContainsKey(id))
{
dic.Add(id, new ExternalLanguage
{
Name = name,
Owner = owner,
CreatedDate = createdDate,
Contents = new List <ExternalLanguageContent>()
});
}
ExternalLanguage metadata = dic[id];
metadata.Contents.Add(new ExternalLanguageContent
{
EnvironmentVariables = envVariables,
Parameters = parameters,
Platform = platform,
ExtensionFileName = extentionFileName
});
}
}
}
return(new List <ExternalLanguage>(dic.Values));
}
public void VerifyDeleteLanguage()
{
ExternalLanguageOperations operations = new ExternalLanguageOperations();
ExternalLanguage language = new ExternalLanguage()
{
Name = "name"
};
Verify(language, (connection, lang, commandMock) =>
{
operations.DeleteLanguage(connection, language.Name);
commandMock.VerifySet(x => x.CommandText = It.Is <string>(s => s.Contains(ExternalLanguageOperations.DropScript)));
return(true);
});
}
private string GetLanguageModifyScript(ExternalLanguage language, List <ExternalLanguageContent> contents, Dictionary <string, object> parameters, ModifyType modifyType, ContentModifyType contentModifyType = ContentModifyType.Add)
{
string contentScript = string.Empty;
for (int i = 0; i < contents.Count; i++)
{
var content = contents[i];
string seperator = contentScript == string.Empty ? "" : ",";
contentScript = $"{contentScript}{seperator}{GetLanguageContent(content, i, parameters)}";
}
string ownerScript = string.IsNullOrWhiteSpace(language.Owner) ? "" : $"AUTHORIZATION [{CUtils.EscapeStringCBracket(language.Owner)}]";
string scriptAction = modifyType == ModifyType.Create ? CreateScript : AlterScript;
string contentAction = "FROM";
if (modifyType == ModifyType.Alter)
{
switch (contentModifyType)
{
case ContentModifyType.Modify:
contentAction = SetContentScript;
break;
case ContentModifyType.Add:
contentAction = AddContentScript;
break;
case ContentModifyType.Remove:
contentAction = RemoveContentScript;
break;
}
}
return($@"
{scriptAction} [{CUtils.EscapeStringCBracket(language.Name)}]
{ownerScript}
{contentAction} {contentScript}
");
}
/// <summary>
///
/// </summary>
/// <param name="connection"></param>
/// <param name="language"></param>
public virtual void UpdateLanguage(IDbConnection connection, ExternalLanguage language)
{
if (string.IsNullOrWhiteSpace(language?.Name))
{
throw new LanguageExtensibilityException($"Failed to update language. language or language name is empty.");
}
Dictionary <string, object> parameters = new Dictionary <string, object>();
ExternalLanguage currentLanguage = GetLanguage(connection, language.Name);
if (currentLanguage == null)
{
ExecuteNonQuery(connection, GetCreateScript(language, parameters), parameters);
}
else
{
foreach (var content in language.Contents)
{
var currentContent = currentLanguage.Contents.FirstOrDefault(x => x.PlatformId == content.PlatformId);
if (currentContent != null)
{
ExecuteNonQuery(connection, GetUpdateScript(language, content, parameters, ContentModifyType.Modify), parameters);
}
else
{
ExecuteNonQuery(connection, GetUpdateScript(language, content, parameters, ContentModifyType.Add), parameters);
}
}
foreach (var currentContent in currentLanguage.Contents)
{
var content = language.Contents.FirstOrDefault(x => x.PlatformId == currentContent.PlatformId);
if (content == null)
{
ExecuteNonQuery(connection, GetUpdateScript(language, currentContent, parameters, ContentModifyType.Remove), parameters);
}
}
}
}
public async void VerifyExternalLanguagListRequestConnectionFailures()
{
ExternalLanguage language = new ExternalLanguage
{
Name = "name"
};
Mock <ExternalLanguageOperations> operations = new Mock <ExternalLanguageOperations>();
ExternalLanguageService service = new ExternalLanguageService()
{
ExternalLanguageOperations = operations.Object
};
await VerifyError <ExternalLanguageListResponseParams>(
test : async(requestContext, connectionUrl) =>
{
ExternalLanguageListRequestParams requestParams = new ExternalLanguageListRequestParams
{
OwnerUri = "invalid connection"
};
await service.HandleExternalLanguageListRequest(requestParams, requestContext);
return(null);
});
}
private string GetUpdateScript(ExternalLanguage language, ExternalLanguageContent content, Dictionary <string, object> parameters, ContentModifyType contentModifyType)
{
return(GetLanguageModifyScript(language, new List <ExternalLanguageContent> {
content
}, parameters, ModifyType.Alter, contentModifyType));
}
private string GetCreateScript(ExternalLanguage language, Dictionary <string, object> parameters)
{
return(GetLanguageModifyScript(language, language.Contents, parameters, ModifyType.Create));
}
private IDbConnection Verify(ExternalLanguage language, Func <IDbConnection, ExternalLanguage, Mock <IDbCommand>, bool> func)
{
Mock <IDbConnection> connectionMock = new Mock <IDbConnection>();
Mock <IDbCommand> commandMock = new Mock <IDbCommand>();
Mock <IDbDataParameter> dbDataParamMock = new Mock <IDbDataParameter>();
Mock <IDataParameterCollection> dbDataParametersMock = new Mock <IDataParameterCollection>();
Mock <IDataReader> dataReaderMock = new Mock <IDataReader>();
bool dataReaderHasValues = language != null;
dataReaderMock.Setup(x => x.Read()).Returns(() => dataReaderHasValues).Callback(() =>
{
dataReaderHasValues = false;
}
);
if (language != null)
{
ExternalLanguageContent content = language.Contents == null || language.Contents.Count == 0 ? null : language.Contents[0];
dataReaderMock.Setup(x => x.GetInt32(0)).Returns(1);
dataReaderMock.Setup(x => x.IsDBNull(1)).Returns(language.Name == null);
dataReaderMock.Setup(x => x.GetString(1)).Returns(language.Name);
dataReaderMock.Setup(x => x.IsDBNull(2)).Returns(language.CreatedDate == null);
if (language.CreatedDate != null)
{
dataReaderMock.Setup(x => x.GetDateTime(2)).Returns(DateTime.Parse(language.CreatedDate));
}
dataReaderMock.Setup(x => x.IsDBNull(3)).Returns(language.Owner == null);
if (language.Owner != null)
{
dataReaderMock.Setup(x => x.GetString(3)).Returns(language.Owner);
}
dataReaderMock.Setup(x => x.IsDBNull(5)).Returns(content == null || content.ExtensionFileName == null);
if (content != null && content.ExtensionFileName != null)
{
dataReaderMock.Setup(x => x.GetString(5)).Returns(content.ExtensionFileName);
}
dataReaderMock.Setup(x => x.IsDBNull(6)).Returns(content == null || content.Platform == null);
if (content != null && content.Platform != null)
{
dataReaderMock.Setup(x => x.GetString(6)).Returns(content.Platform);
}
dataReaderMock.Setup(x => x.IsDBNull(7)).Returns(content == null || content.Parameters == null);
if (content != null && content.Parameters != null)
{
dataReaderMock.Setup(x => x.GetString(7)).Returns(content.Parameters);
}
dataReaderMock.Setup(x => x.IsDBNull(8)).Returns(content == null || content.EnvironmentVariables == null);
if (content != null && content.EnvironmentVariables != null)
{
dataReaderMock.Setup(x => x.GetString(8)).Returns(content.EnvironmentVariables);
}
}
dbDataParametersMock.Setup(x => x.Add(It.IsAny <object>()));
dbDataParamMock.Setup(x => x.ParameterName);
dbDataParamMock.Setup(x => x.Value);
commandMock.Setup(x => x.CreateParameter()).Returns(dbDataParamMock.Object);
commandMock.Setup(x => x.Parameters).Returns(dbDataParametersMock.Object);
commandMock.SetupSet(x => x.CommandText = It.IsAny <string>());
commandMock.Setup(x => x.ExecuteNonQuery());
commandMock.Setup(x => x.ExecuteReader()).Returns(dataReaderMock.Object);
connectionMock.Setup(x => x.CreateCommand()).Returns(commandMock.Object);
func(connectionMock.Object, language, commandMock);
return(connectionMock.Object);
}
