/*-
 * ============LICENSE_START=======================================================
 * Copyright (C) 2018 Ericsson. All rights reserved.
 * ================================================================================
 * Modifications Copyright (C) 2019 Samsung
 * ================================================================================
 * 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.
 * ============LICENSE_END=========================================================
 */
package org.onap.policy.xacml.test.std.pap;

import static org.junit.Assert.*;
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
import org.onap.policy.xacml.std.pap.StdPDPPIPConfig;
import org.onap.policy.xacml.std.pap.StdPDPPolicy;
import org.onap.policy.xacml.std.pap.StdPDPStatus;
import com.att.research.xacml.api.pap.PDPPIPConfig;
import com.att.research.xacml.api.pap.PDPPolicy;
import com.att.research.xacml.api.pap.PDPStatus.Status;

public class StdPDPStatusTest {

    StdPDPStatus stdPDPStatus = new StdPDPStatus();

    @Test
    public void testSetAndGetStatus() {
        Status status = Status.UP_TO_DATE;
        stdPDPStatus.setStatus(status);
        assertEquals(status, stdPDPStatus.getStatus());
    }

    @Test
    public void testSetAndGetLoadErrors() {
        Set<String> errors = new HashSet<>();
        errors.add("An error");
        stdPDPStatus.setLoadErrors(errors);
        assertEquals(errors, stdPDPStatus.getLoadErrors());
    }

    @Test
    public void testSetAndGetLoadWarnings() {
        Set<String> warnings = new HashSet<>();
        warnings.add("An error");
        stdPDPStatus.setLoadWarnings(warnings);
        assertEquals(warnings, stdPDPStatus.getLoadWarnings());
    }

    @Test
    public void testSetAndGetLoadedPolicies() {
        Set<PDPPolicy> loadedPolicies = new HashSet<>();
        loadedPolicies.add(new StdPDPPolicy());
        stdPDPStatus.setLoadedPolicies(loadedPolicies);
        assertEquals(loadedPolicies, stdPDPStatus.getLoadedPolicies());
    }

    @Test
    public void testSetAndGetLoadedRootPolicies() {
        Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
        loadedRootPolicies.add(new StdPDPPolicy());
        stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
        assertEquals(loadedRootPolicies, stdPDPStatus.getLoadedRootPolicies());
    }

    @Test
    public void testSetAndGetFailedPolicies() {
        Set<PDPPolicy> failedPolicies = new HashSet<>();
        failedPolicies.add(new StdPDPPolicy());
        stdPDPStatus.setFailedPolicies(failedPolicies);
        assertEquals(failedPolicies, stdPDPStatus.getFailedPolicies());
    }

    @Test
    public void testSetAndGetLoadedPipConfigs() {
        Set<PDPPIPConfig> loadedPipConfigs = new HashSet<>();
        loadedPipConfigs.add(new StdPDPPIPConfig());
        stdPDPStatus.setLoadedPipConfigs(loadedPipConfigs);
        assertEquals(loadedPipConfigs, stdPDPStatus.getLoadedPipConfigs());
    }

    @Test
    public void testSetAndGetFailedPipConfigs() {
        Set<PDPPIPConfig> failedPipConfigs = new HashSet<>();
        failedPipConfigs.add(new StdPDPPIPConfig());
        stdPDPStatus.setFailedPipConfigs(failedPipConfigs);
        assertEquals(failedPipConfigs, stdPDPStatus.getFailedPipConfigs());
    }

    @Test
    public void testPoliciesOK() {
        assertTrue(stdPDPStatus.policiesOK());
        stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
        assertFalse(stdPDPStatus.policiesOK());
    }

    @Test
    public void testPipConfigOK() {
        assertTrue(stdPDPStatus.pipConfigOK());
        stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
        assertFalse(stdPDPStatus.pipConfigOK());
    }

    @Test
    public void testIsOkFailedPolicy() {
        stdPDPStatus.setStatus(Status.UP_TO_DATE);
        assertTrue(stdPDPStatus.isOk());
        stdPDPStatus.addFailedPolicy(new StdPDPPolicy());
        assertFalse(stdPDPStatus.isOk());
    }

    @Test
    public void testIsOkFailedPipConfig() {
        stdPDPStatus.setStatus(Status.UP_TO_DATE);
        assertTrue(stdPDPStatus.isOk());
        stdPDPStatus.addFailedPipConfig(new StdPDPPIPConfig());
        assertFalse(stdPDPStatus.isOk());
    }

    @Test
    public void testIsOkStatusOutOfSync() {
        stdPDPStatus.setStatus(Status.UP_TO_DATE);
        assertTrue(stdPDPStatus.isOk());
        stdPDPStatus.setStatus(Status.OUT_OF_SYNCH);
        assertFalse(stdPDPStatus.isOk());
    }

    @Test
    public void testAddLoadError() {
        stdPDPStatus.addLoadError("An error");
        assertEquals("An error", stdPDPStatus.getLoadErrors().iterator().next());
    }

    @Test
    public void testAddLoadWarning() {
        stdPDPStatus.addLoadWarning("A warning");
        assertEquals("A warning", stdPDPStatus.getLoadWarnings().iterator().next());
    }

    @Test
    public void testAddLoadedPolicy() {
        PDPPolicy policy = new StdPDPPolicy();
        stdPDPStatus.addLoadedPolicy(policy);
        assertEquals(policy, stdPDPStatus.getLoadedPolicies().iterator().next());
    }

    @Test
    public void testAddRootPolicy() {
        PDPPolicy policy = new StdPDPPolicy();
        stdPDPStatus.addRootPolicy(policy);
        assertEquals(policy, stdPDPStatus.getLoadedRootPolicies().iterator().next());
    }

    @Test
    public void testAddAllLoadedRootPolicy() {
        Set<PDPPolicy> policies = new HashSet<>();
        PDPPolicy policy = new StdPDPPolicy();
        policies.add(policy);
        stdPDPStatus.addAllLoadedRootPolicies(policies);
        assertEquals(policies, stdPDPStatus.getLoadedRootPolicies());
    }

    @Test
    public void testAddLoadedPipConfig() {
        PDPPIPConfig pipConfig = new StdPDPPIPConfig();
        stdPDPStatus.addLoadedPipConfig(pipConfig);
        assertEquals(pipConfig, stdPDPStatus.getLoadedPipConfigs().iterator().next());
    }

    @Test
    public void testSet() {
        Status status = Status.UP_TO_DATE;
        Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
        failedPIPConfigs.add(new StdPDPPIPConfig());
        Set<PDPPolicy> failedPolicies = new HashSet<>();
        failedPolicies.add(new StdPDPPolicy());
        Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
        loadedPIPConfigs.add(new StdPDPPIPConfig());
        Set<PDPPolicy> loadedPolicies = new HashSet<>();
        loadedPolicies.add(new StdPDPPolicy());
        Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
        loadedRootPolicies.add(new StdPDPPolicy());
        Set<String> loadErrors = new HashSet<>();
        loadErrors.add("An error");
        Set<String> loadWarnings = new HashSet<>();
        loadWarnings.add("An error");

        stdPDPStatus.setStatus(status);
        stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
        stdPDPStatus.setFailedPolicies(failedPolicies);
        stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
        stdPDPStatus.setLoadedPolicies(loadedPolicies);
        stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
        stdPDPStatus.setLoadErrors(loadErrors);
        stdPDPStatus.setLoadWarnings(loadWarnings);

        StdPDPStatus stdPDPStatus1 = new StdPDPStatus();
        stdPDPStatus1.set(stdPDPStatus);

        assertEquals(status, stdPDPStatus1.getStatus());
        assertEquals(loadErrors, stdPDPStatus1.getLoadErrors());
        assertEquals(loadWarnings, stdPDPStatus1.getLoadWarnings());
        assertEquals(loadedPolicies, stdPDPStatus1.getLoadedPolicies());
        assertEquals(loadedRootPolicies, stdPDPStatus1.getLoadedRootPolicies());
        assertEquals(failedPolicies, stdPDPStatus1.getFailedPolicies());
        assertEquals(loadedPIPConfigs, stdPDPStatus1.getLoadedPipConfigs());
        assertEquals(failedPIPConfigs, stdPDPStatus1.getFailedPipConfigs());

        assertEquals(
                "StdPDPStatus [status=UP_TO_DATE, loadErrors=[An error], loadWarnings=[An error],"
                        + " loadedPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null,"
                        + " version=, isRoot=false, isValid=false, location=null]],"
                        + " loadedRootPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null,"
                        + " version=, isRoot=false, isValid=false, location=null]],"
                        + " failedPolicies=[StdPDPPolicy [id=null, name=null, policyId=null, description=null,"
                        + " version=, isRoot=false, isValid=false, location=null]], loadedPIPConfigs=[StdPDPPIPConfig"
                        + " [id=null, name=null, description=null, classname=null, config={}]], failedPIPConfigs="
                        + "[StdPDPPIPConfig [id=null, name=null, description=null, classname=null, config={}]]]",
                stdPDPStatus1.toString());
    }

    @Test
    public void testEqualsAndHashCode() {
        Status status = Status.UP_TO_DATE;
        Set<PDPPIPConfig> failedPIPConfigs = new HashSet<>();
        failedPIPConfigs.add(new StdPDPPIPConfig());
        Set<PDPPolicy> failedPolicies = new HashSet<>();
        failedPolicies.add(new StdPDPPolicy());
        Set<PDPPIPConfig> loadedPIPConfigs = new HashSet<>();
        loadedPIPConfigs.add(new StdPDPPIPConfig());
        Set<PDPPolicy> loadedPolicies = new HashSet<>();
        loadedPolicies.add(new StdPDPPolicy());
        Set<PDPPolicy> loadedRootPolicies = new HashSet<>();
        loadedRootPolicies.add(new StdPDPPolicy());
        Set<String> loadErrors = new HashSet<>();
        loadErrors.add("An error");
        Set<String> loadWarnings = new HashSet<>();
        loadWarnings.add("An error");

        StdPDPStatus stdPDPStatus1 = new StdPDPStatus();

        assertTrue(stdPDPStatus.equals(stdPDPStatus1));

        stdPDPStatus.setStatus(status);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setStatus(status);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());

        stdPDPStatus.setFailedPipConfigs(failedPIPConfigs);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setFailedPipConfigs(failedPIPConfigs);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());

        stdPDPStatus.setFailedPolicies(failedPolicies);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setFailedPolicies(failedPolicies);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());

        stdPDPStatus.setLoadedPipConfigs(loadedPIPConfigs);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setLoadedPipConfigs(loadedPIPConfigs);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());

        stdPDPStatus.setLoadedPolicies(loadedPolicies);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setLoadedPolicies(loadedPolicies);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());

        stdPDPStatus.setLoadedRootPolicies(loadedRootPolicies);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setLoadedRootPolicies(loadedRootPolicies);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());

        stdPDPStatus.setLoadErrors(loadErrors);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setLoadErrors(loadErrors);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());

        stdPDPStatus.setLoadWarnings(loadWarnings);
        assertFalse(stdPDPStatus.equals(stdPDPStatus1));
        stdPDPStatus1.setLoadWarnings(loadWarnings);
        assertTrue(stdPDPStatus.equals(stdPDPStatus1));
        assertEquals(stdPDPStatus.hashCode(), stdPDPStatus1.hashCode());
    }

    @Test
    public void testEqualsSameObject() {
        assertTrue(stdPDPStatus.equals(stdPDPStatus));
    }

    @Test
    public void testEqualsNull() {
        assertFalse(stdPDPStatus.equals(null));
    }

    @Test
    public void testEqualsInstanceOfDiffClass() {
        assertFalse(stdPDPStatus.equals(""));
    }
}