public Task InitializeAsync(FileTagsOverviewViewModel context)
{
return(Task.Run(
() =>
{
CreateFileTag = new ViewModelCommand(
"Create",
new RelayCommand(
async() =>
{
await _navigationService.NavigateToFileTagEditAsync(Maybe.CreateNone <string>());
}));
UpdateFileTag = new ViewModelCommand(
"Update",
new RelayCommand(
async() =>
{
await _navigationService.NavigateToFileTagEditAsync(
Maybe.CreateSome(context.SelectedFileTag.Id));
},
() => context.SelectedFileTag != null));
DeleteFileTag = new ViewModelCommand(
"Delete",
new RelayCommand(
async() =>
{
await _fileTagService.DeleteAsync(context.SelectedFileTag.Id);
context.FileTags.Remove(context.SelectedFileTag);
context.SelectedFileTag = null;
},
() => context.SelectedFileTag != null));
}));
}
public void Constructor_WithQueryParameters_AddsQueryParametersToFullUri()
{
const string UriString = "https://www.google.ch";
var baseUri = new Uri(UriString);
const RestCallMethodType MethodType = RestCallMethodType.Get;
var security = RestSecurity.CreateAnonymous();
var headers = new RestHeaders(new List <RestHeader>());
var body = Maybe.CreateSome(RestCallBody.CreateApplicationJson(new object()));
var queryParameterList = new List <QueryParameter> {
new QueryParameter("Key1", "Value1", "Value2"), new QueryParameter("Key2", "Value3")
};
const string ExpectedUriString = UriString + "?Key1=Value1&Key1=Value2&Key2=Value3";
var expectedFullUri = new Uri(ExpectedUriString);
var queryParameters = new QueryParameters(queryParameterList);
ConstructorTestBuilderFactory.Constructing <RestCall>()
.UsingDefaultConstructor()
.WithArgumentValues(baseUri, Maybe.CreateNone <string>(), MethodType, security, headers, body, queryParameters)
.Maps()
.ToProperty(f => f.AbsoluteUri).WithValue(expectedFullUri)
.BuildMaps()
.Assert();
}
internal MxCell Build()
{
var geometry = _geometryBuilder.Evaluate <Maybe <MxGeometry> >(
builder => builder.Build(),
() => Maybe.CreateNone <MxGeometry>());
return(new MxCell(_id, _value, _style, _vertex, _parent, geometry));
}
public void CreatingNoneMaybe_CreatesNone()
{
// Act
var actualNoneMaybe = Maybe.CreateNone <object>();
// Assert
actualNoneMaybe.Should().BeOfType <None <object> >();
}
protected override async void OnStartup(StartupEventArgs e)
{
var appIcon = TestUI.Properties.Resources.M;
var assemblyParameters = ContainerConfiguration.CreateFromAssembly(typeof(App).Assembly);
var appConfig = ApplicationConfiguration.CreateFromIcon("Hello Test", appIcon);
await BootstrapService.StartUpAsync(assemblyParameters, appConfig, Maybe.CreateNone <Action>());
}
public Maybe <ICredentials> ToNetCredentials()
{
if (string.IsNullOrEmpty(_userName))
{
return(Maybe.CreateNone <ICredentials>());
}
return(new NetworkCredential(_userName, _password));
}
internal static RestCall CreatePostOneTodoRestCall(string todoJson)
{
return(new RestCall(
new Uri("https://jsonplaceholder.typicode.com/comments"),
Maybe.CreateNone <string>(),
RestCallMethodType.Post,
RestSecurity.CreateAnonymous(),
new RestHeaders(new List <RestHeader>()),
RestCallBody.CreateApplicationJson(todoJson),
new QueryParameters(new List <QueryParameter>())));
}
internal static RestCall CreateDefaultRestCall()
{
return(new RestCall(
new Uri("https://www.google.ch"),
Maybe.CreateNone <string>(),
RestCallMethodType.Get,
RestSecurity.CreateAnonymous(),
new RestHeaders(new List <RestHeader>()),
Maybe.CreateNone <RestCallBody>(),
new QueryParameters(new List <QueryParameter>())));
}
internal static RestCall CreateNotExistingPostRestCall()
{
return(new RestCall(
new Uri("https://google.com/"),
Maybe.CreateNone <string>(),
RestCallMethodType.Post,
RestSecurity.CreateAnonymous(),
new RestHeaders(new List <RestHeader>()),
Maybe.CreateNone <RestCallBody>(),
new QueryParameters(new List <QueryParameter>())));
}
public void Mapping_MaybeBeingNone_ReturnsSameNone()
{
// Arrange
var noneMaybe = Maybe.CreateNone <object>();
// Act
var actualMaybe = noneMaybe.Map(f => f.ToString());
// Assert
actualMaybe.Should().BeOfType(typeof(None <string>));
}
internal static RestCall CreateGetOneTodoRestCall()
{
return(new RestCall(
new Uri("https://jsonplaceholder.typicode.com/todos/1"),
Maybe.CreateNone <string>(),
RestCallMethodType.Get,
RestSecurity.CreateAnonymous(),
new RestHeaders(new List <RestHeader>()),
Maybe.CreateNone <RestCallBody>(),
new QueryParameters(new List <QueryParameter>())));
}
public void ComparingMaybes_BothBeingNone_ReturnsTrue()
{
// Arrange
var none1 = Maybe.CreateNone <object>();
var none2 = Maybe.CreateNone <object>();
// Act
var areEqual = none1 == none2;
// Assert
areEqual.Should().BeTrue();
}
public async Task <Maybe <string> > TryFindingIdByNameAsync(string namepart)
{
using var client = _clientFactory.Create();
var containers = await client.Containers.ListContainersAsync(new ContainersListParameters { All = true });
var existingContainer = containers.SingleOrDefault(f => f.Names.Contains("/" + namepart));
return(existingContainer == null
? Maybe.CreateNone <string>()
: existingContainer.ID);
}
public void ComparingMaybes_OneBeingNoneOneBeingSome_ReturnsFalse()
{
// Arrange
var none = Maybe.CreateNone <string>();
Maybe <string> some = "tra";
// Act
var areEqual = none == some;
// Assert
areEqual.Should().BeFalse();
}
public Task Given_the_user_is_about_to_call_a_nonexisting_url()
{
_restCall = new RestCall(
new Uri("https://googlewdwwfwef.com/"),
Maybe.CreateNone <string>(),
RestCallMethodType.Post,
RestSecurity.CreateAnonymous(),
new RestHeaders(new List <RestHeader>()),
Maybe.CreateNone <RestCallBody>(),
new QueryParameters(new List <QueryParameter>()));
return(Task.CompletedTask);
}
public async Task <Maybe <DailyReport> > LoadByDateAsync(DateTime date)
{
var dataModel = await _dataModelRepository.LoadSingleAsync(f => f.Date.Date == date.Date);
if (dataModel == null)
{
return(Maybe.CreateNone <DailyReport>());
}
var result = _dataModelAdapter.Adapt(dataModel);
return(result);
}
private static DataElement Adapt(XElement dataXmlElement)
{
var name = dataXmlElement.Attribute("name").Value;
var value = dataXmlElement.Element("value").Value;
var commentElement = dataXmlElement.Element("comment");
var comment =
commentElement == null?
Maybe.CreateNone <string>() :
Maybe.CreateSome(commentElement.Value);
return(new DataElement(name, value, comment));
}
public async Task ReducingAsync_MaybeBeingNone_ReturnsCallbackValue()
{
// Arrange
const string CallbackValue = "1234";
var someMaybe = Maybe.CreateNone <string>();
// Act
var actualValue = await someMaybe.ReduceAsync(() => Task.FromResult(CallbackValue));
// Assert
actualValue.Should().Be(CallbackValue);
}
public void Reducing_MaybeBeingNone_ReturnsCallbackValue()
{
// Arrange
const string CallbackValue = "1234";
var someMaybe = Maybe.CreateNone <string>();
// Act
var actualValue = someMaybe.Reduce(() => CallbackValue);
// Assert
actualValue.Should().Be(CallbackValue);
}
internal static RestCall CreateCommentsByPostIdRestCall()
{
var queryParameters = new List <QueryParameter> {
new QueryParameter("postId", 1)
};
return(new RestCall(
new Uri("https://jsonplaceholder.typicode.com/comments"),
Maybe.CreateNone <string>(),
RestCallMethodType.Get,
RestSecurity.CreateAnonymous(),
new RestHeaders(new List <RestHeader>()),
Maybe.CreateNone <RestCallBody>(),
new QueryParameters(queryParameters)));
}
public static Maybe <TEnum> TryParse <TEnum>(int value)
where TEnum : struct, IConvertible
{
if (!typeof(TEnum).IsEnum)
{
throw new ArgumentException($"TEnum ({typeof(TEnum).Name}) is not an enumeration type.");
}
var parseResult = Enum.TryParse <TEnum>(value.ToString(), out var result);
// Note that Enum.TryParse only returns false if unable to convert the value, not if the value isn't defined as an underlying enum value.
var isValidEnum = parseResult && Enum.IsDefined(typeof(TEnum), result);
return(isValidEnum ? result : Maybe.CreateNone <TEnum>());
}
public static Maybe <TimeStamp> TryParsing(string str)
{
if (string.IsNullOrEmpty(str))
{
return(Maybe.CreateNone <TimeStamp>());
}
var reg = new Regex("([0-9]{1,2})(:)([0-9]{1,2})");
if (!reg.IsMatch(str))
{
return(Maybe.CreateNone <TimeStamp>());
}
return(Parse(str));
}
public Task Given_the_user_is_about_to_fetch_comments_per_post_id()
{
var queryParameters = new List <QueryParameter> {
new QueryParameter("postId", PostId)
};
_restCall = new RestCall(
new Uri("https://jsonplaceholder.typicode.com/comments"),
Maybe.CreateNone <string>(),
RestCallMethodType.Get,
RestSecurity.CreateAnonymous(),
new RestHeaders(new List <RestHeader>()),
Maybe.CreateNone <RestCallBody>(),
new QueryParameters(queryParameters));
return(Task.CompletedTask);
}
public IReadOnlyCollection <TextTranslationRequest> CreateRequests(
string targetLanguageCode,
Maybe <string> sourceLanguageCode,
Maybe <IgnoreForTranslationMarkup> ignoreMarkup,
params IdentifiableText[] textParts)
{
var targetLanguage = TranslationLanguage.CreateByCode(targetLanguageCode);
var sourceLanguage = sourceLanguageCode.Evaluate(
code => Maybe.CreateSome(TranslationLanguage.CreateByCode(code)),
() => Maybe.CreateNone <TranslationLanguage>());
var textPartChunks = textParts.Chunk(TextTranslationRequest.MaxTextParts);
var result = textPartChunks
.Select(chunk => new TextTranslationRequest(targetLanguage, sourceLanguage, ignoreMarkup, chunk.ToList()))
.ToList();
return(result);
}
private ReportEntry AdaptReportEntry(ReportEntryDataModel dataModel)
{
var beginTime = new TimeStamp(dataModel.BeginTime.Hour, dataModel.BeginTime.Minute);
Maybe <TimeStamp> endTime;
if (string.IsNullOrEmpty(dataModel.EndTime.Hour))
{
endTime = Maybe.CreateNone <TimeStamp>();
}
else
{
endTime = new TimeStamp(dataModel.EndTime.Hour, dataModel.EndTime.Minute);
}
var result = _reportEntryFactory.Create(beginTime, endTime, dataModel.WorkDescription, dataModel.Id);
return(result);
}
public Maybe <string> LocateDropboxPath()
{
var appDataPathResult = TryGettingAppDataPath();
if (appDataPathResult.IsSuccess)
{
var dropboxPath = _fileSystem.File.ReadAllText(appDataPathResult.Value).Split('\"')[5].Replace(@"\\", @"\");
return(dropboxPath);
}
// Fallback, check if system variable is set
var dropboxPathViaSystemVariable = GetDropboxPathViaSystemVariable();
if (string.IsNullOrEmpty(dropboxPathViaSystemVariable))
{
return(Maybe.CreateNone <string>());
}
return(dropboxPathViaSystemVariable);
}
public async Task <PythonExecutionResult> ExecuteAsnc(PythonExecutionRequest request)
{
var startInfo = _startInfoFactory.CreateForExecution(request);
using (var process = Process.Start(startInfo))
{
var errorString = await process.StandardError.ReadToEndAsync();
string resultString = null;
using (var reader = process.StandardOutput)
{
resultString = await reader.ReadToEndAsync();
process.WaitForExit();
}
var err = string.IsNullOrEmpty(errorString) ? Maybe.CreateNone <string>() : Maybe.CreateSome(errorString);
var res = string.IsNullOrEmpty(resultString) ? Maybe.CreateNone <string>() : Maybe.CreateSome(resultString);
return(new PythonExecutionResult(res, err));
}
}
public TestingCapabilitiesBuilder()
{
_configExpressionMaybe = Maybe.CreateNone <Action <IMapperConfigurationExpression> >();
}
