Untitled

 avatar
unknown
plain_text
a month ago
17 kB
6
Indexable

    @Integration @API
    Scenario Outline: Channels v4 API returns expected response
      * The IPVS channels v4 call with valid headers "<x-accountId>" and "<x-mso>" and "<ip>" should return expected channel data structure
      Examples:
        | x-accountId                   | x-mso   | ip      |
        | LNK.8347:8347100040106596     | TWC     | 1.2.3.4 |
        | CHARTER.8286:8286101621622343 | CHARTER | 1.2.3.4 |




package stepdefs.ipvs;

import io.cucumber.java.en.*;
import sth.ResponseData;
import sth.ServiceApiResponse;
import sth.ipvs.ipvs.IPVSBaseTest;
import sth.json.JSON;
import sth.ipvs.saint.restservice.models.MarketLineup;
import com.google.gson.GsonBuilder;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;

public class IPVSApiTests extends IPVSBaseTest {
    private static final List<String> REQUIRED_CHANNEL_FIELDS = Arrays.asList("name", "ncsNetworkId", "logoUrl", "services");
    private static final List<String> REQUIRED_LINEAR_FIELDS = Arrays.asList(
            "callSign", "serviceName", "ncsServiceId", "tmsGuideId", "entitled", "online", "qam", "4k",
            "mystroServiceId", "cdvrRecordable", "availableInMarket", "availableOutOfMarket"
    );
    private static final List<String> REQUIRED_VOD_FIELDS = Arrays.asList(
            "serviceName",  "ncsServiceId", "entitled"
    );

    @When("I make a successful IPVS lineupv1 call with {string} and {string}")
    public void call_api_smarttv_lineupv1 (String account, String mso) {
        ResponseData.setData("accountId", account);
        ResponseData.setData("mso", mso);

        ServiceApiResponse response = restIPVS().apiSmarttvLineupV1(account,mso,"1.2.3.4").get();
        ResponseData.setResponse("apiSmarttvLineupV1", Objects.requireNonNull(response.json()));

        assertTrue(response.status().isSuccess(), response.uri() + " call is failing with " + response.status() + " and TXID: " + response.txId());
        assertNotNull(response.json().get("market"), "Required field 'market' not found");
        assertNotNull(response.json().get("lineupId"), "Required field 'lineupID' not found");
        assertNotNull(response.json().get("headend"), "Required field 'headend' not found");
        assertNotNull(response.json().get("vodId"), "Required field 'vodId' not found");
    }

    @Then("the IPVS lineupv1 response should match the SAINT apicustomer response")
    public void match_lineupv1_with_saint_customer_call() {
        JSON ipvsResponse = ResponseData.getResponse("apiSmarttvLineupV1");
        ServiceApiResponse saintResponse = restSAINT().apiCustomer("1.2.3.4",
                ResponseData.getData("accountId"), "marketlineup", ResponseData.getData("mso")).get();
        assertTrue(saintResponse.status().isSuccess(), saintResponse.uri() + " call is failing with " + saintResponse.status() + " and TXID: " + saintResponse.txId());

        MarketLineup saintLineup = new GsonBuilder().create().fromJson(saintResponse.json().get("marketLineup").toString(), MarketLineup.class);
        assertNotNull(saintLineup.market, "Required field 'market' not found");
        assertNotNull(saintLineup.lineupId, "Required field 'lineupID' not found");

        assertEquals(ipvsResponse.get("market").toString(), saintLineup.market,
                "Market value does not match; Saint response ID: " + saintResponse.txId());
        assertEquals(ipvsResponse.get("vodId").toString(), saintLineup.market,
                "Market value does not match; Saint response ID: " + saintResponse.txId());
        assertEquals(ipvsResponse.get("lineupId").toString(), saintLineup.lineupId.toString(),
                "Market value does not match; Saint response ID: " + saintResponse.txId());
        assertEquals(ipvsResponse.get("headend").toString(), saintLineup.market+"_"+saintLineup.lineupId,
                "Market value does not match; Saint response ID: " + saintResponse.txId());
    }

    @Then("The IPVS channels v4 call with valid headers {string} and {string} and {string} should return expected channel data structure")
    public void request_and_verify_ipvs_channelsv4_data(String xAccountId, String xMso, String ip) {
        ResponseData.setData("accountId", xAccountId);
        ResponseData.setData("mso", xMso);
        ResponseData.setData("ip", ip);

        ServiceApiResponse ipvsResponse = restIPVS().apiSmarttvChannelsV4(xAccountId, xMso, ip, null, null, null, null, null).get();
        ResponseData.setResponse("apiSmarttvChannelsV4", Objects.requireNonNull(ipvsResponse.json()));

        assertTrue(ipvsResponse.isSuccess(), ipvsResponse.uri() + " Call failed with " + ipvsResponse.status() + " and TXID: " + ipvsResponse.txId());

        JSON json = ipvsResponse.json();

        assertTrue(json.size() > 0, "Response array should not be empty");

        for (int i=0; i<json.size(); i++) {
            validateChannelData(json.get(i));
        }
    }

    private void validateChannelData(JSON channelData) {
        for (String field : REQUIRED_CHANNEL_FIELDS) {
            assertTrue(channelData.hasField(field), "Channel object missing '" + field + "' field");
        }

        assertTrue(channelData.hasField("services"), "Channel object missing 'services' field");
        JSON services = channelData.get("services");

        if (services.hasField("linear")) {
            validateLinearServices(services.get("linear"));
        }

        if (services.hasField("vod")) {
            validateVodServices(services.get("vod"));
        }
    }

    private void validateLinearServices(JSON linearServices) {
        String errors = "";
        for(int i=0; i<linearServices.size(); i++) {
            JSON linear = linearServices.get(i);
            for (String field : REQUIRED_LINEAR_FIELDS) {
                if(!linear.hasField(field)) {
                    errors += "Linear service at index " + i + " missing '" + field + "' field\n";
                }
            }
            errors += validateArrayField(linear, "channelNumbers", errors, i);
            errors += validateArrayField(linear, "genres", errors, i);
        }
        if(!errors.isEmpty()) {
            System.out.println("VALIDATION WARNINGS: " + errors);
        }
    }

    private void validateVodServices(JSON vodServices) {
        String errors = "";
        for(int i=0; i<vodServices.size(); i++) {
            JSON vod = vodServices.get(i);
            for (String field : REQUIRED_VOD_FIELDS) {
                if(!vod.hasField(field)) {
                    errors += "VOD service at index " + i + " missing '" + field + "' field\n";
                }
            }
            errors += validateArrayField(vod, "productProviders", errors, i);
        }
        if(!errors.isEmpty()) {
            System.out.println("VALIDATION WARNINGS: " + errors);
        }
    }

    private String validateArrayField(JSON json, String fieldName, String errors, int index) {
        if (json.hasField(fieldName)) {
            Object field = json.get(fieldName);
            if (!(field instanceof JSON) || !((JSON) field).isArray()) {
                return "Service at index " + index + ": " + fieldName + " is not an array\n";
            }
        }
        return "";
    }

    @Override
    public void verifyTestData() {}
}


	public IPVSApiController apiSmarttvChannelsV4 (String xAccountId, String xMso, String queryIp, String customerGuid, String xPiForwardedFor, Boolean includeAdultChannels, Boolean includeQAM, Boolean includeUnentitled) {
		request.reset();
		request.path(API);
		request.path(SMARTTV);
		request.path(CHANNELS);
		request.path(V4);
		if (xAccountId != null) {
			headerXAccountid(xAccountId);
		}
		if (xMso != null) {
			headerXMso(xMso);
		}
		queryIp(queryIp);
		headerCustomerGuid(customerGuid);
		headerXPiForwardedFor(xPiForwardedFor);
		if (includeAdultChannels != null) {
			queryIncludeadultchannels(includeAdultChannels);
		}
		if (includeQAM != null) {
			queryIncludeqam(includeQAM);
		}
		if (includeUnentitled != null) {
			queryIncludeunentitled(includeUnentitled);
		}
		return this;
	}


	/**
	 * Path method for endpoint "api/smarttv/channels/v4"
	 * This method is used to build only the request path for endpoint "api/smarttv/channels/v4".
	 * Use this method if you would like to build requests using the builder pattern
	 * with the corresponding query parameter builder helper methods in this class.
	 */
	public IPVSApiController apiSmarttvChannelsV4 () {
		request.reset();
		request.path(API);
		request.path(SMARTTV);
		request.path(CHANNELS);
		request.path(V4);
		return this;
	}


package sth;

import org.apache.commons.io.IOUtils;
import org.testng.Assert;
import sth.http.ServiceResponse;
import sth.http.client.Request;
import sth.http.client.Response;
import sth.http.common.HttpStatus;
import sth.json.JSON;
import sth.xml.XML;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * A wrapper around the Request/Response dialog between HTTP client and server. For specific
 * use cases further methods could be added (for example to deserialize proprietary formats).
 */
public class ServiceApiResponse implements ServiceResponse {

    private Request request;
    private Response response;

    public ServiceApiResponse(Request request, Response response) {
        this.request = request;
        this.response = response;
    }

    public String txId() {return request.getHeader("x-request-id");}

    /**
     * Get the {@link Request} object that was executed to create the {@link Response}
     */
    public Request request() {
        return request;
    }

    /**
     * Get the underlying {@link Response} object
     */
    public Response response() {
        return response;
    }

    /**
     * True if the response status code is in the success range (200-299)
     */
    public boolean isSuccess() {
        return response.status().isSuccess();
    }

    /**
     * Assert that the response status code was in the success range (200-299)
     */
    public ServiceApiResponse assertSuccess() {
        String errorMessage = "Request failed with status code " + response.status() + "\nRequest URL: " + request.uri() +
                "\nTime: " + System.currentTimeMillis() + " ; TxId: " + header("x-trace-id");
        if (response.getHeader("X-Failure-Message") != null)
            errorMessage = errorMessage + "\nX-Failure-Message: " + header("X-Failure-Message");

        if (response.getHeader("Failure-Trace") != null)
            errorMessage = errorMessage + "\nFailure-Trace: " + header("Failure-Trace");
        try {
            if (response.getBody() != null)
                errorMessage = errorMessage + "\nBody: " + IOUtils.toString(response.bodyInputStream(), StandardCharsets.UTF_8).replaceAll("<.*?>", "");
        }
        catch (IOException e){System.out.println("VSIERROR, IOUtils.toString: " + e.getMessage());}

        Assert.assertTrue(isSuccess(), errorMessage);
        return this;
    }

    /**
     * True if the response status code is in the error range (>=400)
     */
    public boolean isError() {
        return response.status().isError();
    }

    /**
     * Parse the response body to a JSON object
     */
    public JSON json() {
        return response.as(JSON.class);
    }

    /**
     * Parse the response body to an XML object
     */
    public XML xml() {
        return response.as(XML.class);
    }

    /**
     * Get the response body as a String
     */
    public String responseString() {
        return response.as(String.class);
    }

    /**
     * Get HTTP status from response
     */
    public HttpStatus status() {
        return response.status();
    }

    /**
     * Get the HTTP status code of the response
     */
    public int statusCode() {
        return response.status().code();
    }

    /**
     * Get the request URI that was executed
     */
    public String uri() {
        return request.uri().toString();
    }

    /**
     * Get a response header
     */
    public String header(String headerName) {
        return response.header(headerName);
    }

    @Override
    public String toString() {
        String contentType = response.header("content-type");
        if (contentType.contains("json")) {
            return json().toString(3);
        } else if (contentType.contains("xml")) {
            return xml().toString(3);
        } else {
            return responseString();
        }
    }
}

package sth;

import sth.template.rest.TemplateResponse;
import sth.json.JSON;

import java.util.HashMap;
import java.util.LinkedHashMap;

public class ResponseData {
	private static LinkedHashMap<String, HashMap<String, Object>> responseDataMap = new LinkedHashMap<>();
	private static HashMap<String, Object> responseData = new HashMap<>();

	public static void setKeyId(String keyId) {
		if (!responseDataMap.containsKey(keyId)) {
			responseDataMap.put(keyId, responseData);
		}
	}

	public static void setQueryParams(Object param, Object value) {
		// TODO Auto-generated method stub

	}
	
	public static void removeData(String key) {
		try {
			responseData.remove(key);
		} catch (Exception e) {
			// Key not found;
			System.out.println("VSIERR: Failed to remove key " + key + ". Error: " + e.getMessage());
		}
	}

	public static void clear() { responseData.clear();}

	public static void setResponse(JSON json) {responseData.put("response", json);}

	public static void setResponse(String endpoint, JSON json) {responseData.put(endpoint, json);}
	
	public static void setResponseheader(TemplateResponse response) {
		responseData.put("_x-trace-id", response.header("x-trace-id"));
		responseData.put("_responseCode", response.statusCode());
		responseData.put("timestamp", String.valueOf(System.currentTimeMillis()));
		responseData.put("Lantern-Source", response.header("lantern-source"));
	}
	
	public static void setResponseheader(String endpoint, TemplateResponse response) {
		responseData.put(endpoint+"_x-trace-id", response.header("x-trace-id"));
		responseData.put(endpoint+"_responseCode", response.statusCode());
		responseData.put(endpoint+"_timestamp", String.valueOf(System.currentTimeMillis()));
		responseData.put(endpoint+"_URI", response.uri());
		responseData.put(endpoint+"_Lantern-Source", response.header("lantern-source"));
	}

	public static Object getLanternResponseheader(String endpoint){
		return responseData.get(endpoint+"_Lantern-Source");
	}

	public static void removeResponseheader(String endpoint) {
		responseData.remove(endpoint+"_URI");
		responseData.remove(endpoint+"_timestamp");
		responseData.remove(endpoint+"_x-trace-id");
		responseData.remove(endpoint+"_responseCode");
		responseData.remove(endpoint);
	}
	
	public static JSON getResponse() {return (JSON) responseData.get("response");}

	public static JSON getResponse(String endpoint) {return (JSON) responseData.get(endpoint);}

	public static String getTransactionId() {return (String) responseData.get("x-trace-id");}

	public static String getTransactionId(String endpoint) {return (String) responseData.get(endpoint+"_x-trace-id");}

	public static String getTimestamp(String endpoint) {return (String) responseData.get(endpoint+"_timestamp");}

	public static String getRequestUri(String endpoint) {return (String) responseData.get(endpoint+"_URI");}

	public static String getData(String value) {return (String) responseData.get(value);}

	public static int getIntData(String value) {return (int) responseData.get(value);} //New Method

	/**
	 * Returns 0 if, and only if, { #responseData.get(endpoint+"responseCode")} is {@code null}.
	 *
	 * Otherwise, returns the last Response Code received from the { #endpoint}
	 */
	public static int getResponseCode(String endpoint) {
		if (!endpoint.isEmpty()) endpoint = endpoint + "_";

		try {
			return (int) responseData.get(endpoint+"responseCode");
		} catch (NullPointerException e) {
			return 0;
		}
	}

	public static int getResponseCode() {return getResponseCode("");}

	public static void setData(String key, JSON value) {responseData.put(key,value);}

	public static void setData(String key, boolean value) {responseData.put(key,value);}

	public static void setData(String key, String value) {responseData.put(key,value);}

	public static void setData(String key, int value) {responseData.put(key,value);}

	public static void printData() {responseData.forEach((key, value) -> System.out.println(key + " : " + value));}

	public static void printData(String key) {System.out.println(responseData.get(key));}

	public static boolean getBooleanData(String key) {
		try {
			return Boolean.parseBoolean((String) responseData.get(key));
		} catch (Exception e) {
			return (boolean) responseData.get(key);
		}
	}
}



Editor is loading...
Leave a Comment