Exemple #1
0
        public void Constructor_Works()
        {
            var          baseUri = new Uri("https://www.google.ch");
            const string ActualResourcePathString = "Test";

            Maybe <string>           resourcePath = ActualResourcePathString;
            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 expectedFullUri = new Uri(baseUri, "/" + ActualResourcePathString);
            var queryParameters = new QueryParameters(new List <QueryParameter>());

            ConstructorTestBuilderFactory.Constructing <RestCall>()
            .UsingDefaultConstructor()
            .WithArgumentValues(baseUri, resourcePath, MethodType, security, headers, body, queryParameters)
            .Maps()
            .ToProperty(f => f.BaseUri).WithValue(baseUri)
            .ToProperty(f => f.Body).WithValue(body)
            .ToProperty(f => f.Headers).WithValue(headers)
            .ToProperty(f => f.MethodType).WithValue(MethodType)
            .ToProperty(f => f.ResourcePath).WithValue(resourcePath)
            .ToProperty(f => f.Security).WithValue(security)
            .ToProperty(f => f.AbsoluteUri).WithValue(expectedFullUri)
            .BuildMaps()
            .Assert();
        }
Exemple #2
0
        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();
        }
Exemple #3
0
        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));
            }));
        }
Exemple #4
0
        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 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);
        }
 public ITestingCapabilitiesBuilder WithAutoMapper(Action <IMapperConfigurationExpression> config)
 {
     _configExpressionMaybe = Maybe.CreateSome(config);
     return(this);
 }
Exemple #7
0
        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));
            }
        }