com.zebrunner.carina.dataprovider.DataProviderParameterGenerator Maven / Gradle / Ivy

Go to download
package com.zebrunner.carina.dataprovider;

/*******************************************************************************
 * Copyright 2020-2022 Zebrunner Inc (https://www.zebrunner.com).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/

import com.zebrunner.carina.utils.R;
import com.zebrunner.carina.utils.StringGenerator;
import com.zebrunner.carina.utils.commons.SpecialKeywords;
import com.zebrunner.carina.utils.config.Configuration;
import com.zebrunner.carina.utils.config.StandardConfigurationOption;
import com.zebrunner.carina.utils.exception.InvalidArgsException;
import com.zebrunner.carina.utils.parser.xls.XLSParser;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.ITestNGMethod;

import java.lang.invoke.MethodHandles;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DataProviderParameterGenerator {

    private static final Logger LOGGER = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
    private static final Pattern GENERATE_UUID_PATTERN = Pattern.compile(SpecialKeywords.GENERATE_UUID);
    private static final Pattern GENERATE_PATTERN = Pattern.compile(SpecialKeywords.GENERATE);
    private static final Pattern GENERATEAN_PATTERN = Pattern.compile(SpecialKeywords.GENERATEAN);
    private static final Pattern GENERATEN_PATTERN = Pattern.compile(SpecialKeywords.GENERATEN);
    private static final Pattern TESTDATA_PATTERN = Pattern.compile(SpecialKeywords.TESTDATA);
    private static final Pattern ENV_PATTERN = Pattern.compile(SpecialKeywords.ENV);
    private static final Pattern EXCEL_PATTERN = Pattern.compile(SpecialKeywords.EXCEL);
    private static String uuid;

    private DataProviderParameterGenerator() {
        // do nothing
    }

    public static Object process(String param) {
        try {
            if (param == null || param.equalsIgnoreCase("nil")) {
                return null;
            }

            Matcher matcher = GENERATE_UUID_PATTERN.matcher(param);
            if (matcher.find()) {
                return StringUtils.replace(param, matcher.group(), uuid);
            }
            matcher = GENERATE_PATTERN.matcher(param);
            if (matcher.find()) {
                int start = param.indexOf(':') + 1;
                int end = param.indexOf('}');
                int size = Integer.parseInt(param.substring(start, end));
                return StringUtils.replace(param, matcher.group(), StringGenerator.generateWord(size));
            }

            matcher = GENERATEAN_PATTERN.matcher(param);
            if (matcher.find()) {
                int start = param.indexOf(':') + 1;
                int end = param.indexOf('}');
                int size = Integer.parseInt(param.substring(start, end));
                return StringUtils.replace(param, matcher.group(), StringGenerator.generateWordAN(size));
            }

            matcher = GENERATEN_PATTERN.matcher(param);
            if (matcher.find()) {
                int start = param.indexOf(':') + 1;
                int end = param.indexOf('}');
                int size = Integer.parseInt(param.substring(start, end));
                return StringUtils.replace(param, matcher.group(), StringGenerator.generateNumeric(size));
            }

            matcher = ENV_PATTERN.matcher(param);
            if (matcher.find()) {
                int start = param.indexOf(':') + 1;
                int end = param.indexOf('}');
                String key = param.substring(start, end);
                return StringUtils.replace(param, matcher.group(), Configuration.get(key, StandardConfigurationOption.ENVIRONMENT).orElse(""));
            }

            matcher = TESTDATA_PATTERN.matcher(param);
            if (matcher.find()) {
                int start = param.indexOf(':') + 1;
                int end = param.indexOf('}');
                String key = param.substring(start, end);
                return StringUtils.replace(param, matcher.group(), R.TESTDATA.get(key));
            }

            matcher = EXCEL_PATTERN.matcher(param);
            if (matcher.find()) {
                int start = param.indexOf(':') + 1;
                int end = param.indexOf('}');
                String key = param.substring(start, end);
                return StringUtils.replace(param, matcher.group(), getValueFromXLS(key));
            }
        } catch (Exception e) {
            LOGGER.error(e.getMessage());
        }
        return param;
    }

    public static void processMap(Map paramsMap) {
        paramsMap.entrySet()
                .stream()
                .filter(Objects::nonNull).forEach(entry -> {
                    String value = entry.getValue();
                    if (value == null)
                        return;
                    Object param = process(value);
                    if (param == null)
                        return;
                    String newValue = param.toString();
                    if (!value.equals(newValue)) {
                        entry.setValue(newValue);
                    }
                });
    }

    private static String getValueFromXLS(String xlsSheetKey) {
        if (StringUtils.isEmpty(xlsSheetKey)) {
            throw new InvalidArgsException("Invalid excel key, should be 'xls_file#sheet#key'.");
        }

        String xls = xlsSheetKey.split("#")[0];
        String sheet = xlsSheetKey.split("#")[1];
        String key = xlsSheetKey.split("#")[2];

        return XLSParser.parseValue(xls, sheet, key);
    }

    public static String getUUID() {
        return uuid;
    }

    public static void setUUID(String uUID) {
        uuid = uUID;
    }

    /**
     * Generate hash by class name, method name and arg values.
     *
     * @param args   Object[] test method arguments
     * @param method ITestNGMethod
     * @return String hash
     */
    public static String hash(Object[] args, ITestNGMethod method) {
        String toHash = "";
        toHash += Arrays.hashCode(args);
        toHash += method.getMethodName();
        toHash += (method.getRealClass());
        return String.valueOf(toHash.hashCode());
    }
}