Summary Table

Categories Total Count
PII 0
URL 0
DNS 0
EKL 0
IP 0
PORT 0
VsID 0
CF 0
AI 0
VPD 0
PL 0
Other 0

File Content

/*
* SeocServiceHelperTest.java
* Copyright (c) 2017 Veterans Affairs.
*/
package gov.va.oneconsult.seoc.api.service;

import static org.assertj.core.api.Assertions.assertThat;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.junit.Test;

import gov.va.oneconsult.seoc.api.controller.SeocObjectGenerator;
import gov.va.oneconsult.seoc.api.exceptions.SeocConstraintViolationException;
import gov.va.oneconsult.seoc.api.model.BillingCode;
import gov.va.oneconsult.seoc.api.model.ClinicalService;
import gov.va.oneconsult.seoc.api.model.Hptc;
import gov.va.oneconsult.seoc.api.model.PayableService;
import gov.va.oneconsult.seoc.api.model.Seoc;
import gov.va.oneconsult.seoc.api.model.Status;
import gov.va.oneconsult.seoc.api.service.impl.SeocServiceHelper;
import gov.va.oneconsult.seoc.api.util.ApiUtil;
import gov.va.oneconsult.seoc.api.util.Constants;

/**
*
* @author AbleVets
*
*/
public class SeocServiceHelperTest
{

private Status dateHold = SeocObjectGenerator.getStatus(1, Constants.STATUS_DATEHOLD);
/****** Test cases for findNewBillingCodes() ******/

/**
* Description: Source has no billing codes and request has two new billing
* codes check if all the billing codes are identified as new billing codes.
*/
@Test
public void findNewBillingCodes_allnew()
{
Set<BillingCode> sourceBC = null;
Set<BillingCode> requestBC = new HashSet<BillingCode>();

requestBC.add(SeocObjectGenerator.bc1);
requestBC.add(SeocObjectGenerator.bc2);

Set<BillingCode> newBC = SeocServiceHelper.findNewBillingCodes(sourceBC, requestBC);

assertThat(newBC).size().isEqualTo(requestBC.size());
newBC.forEach(bc ->
{
assertThat(requestBC).contains(bc);
});
}

/**
* Description: No change in source and request billing codes. Should return
* empty list.
*/
@Test
public void findNewBillingCodes_nothingNew()
{
Set<BillingCode> sourceBC = new HashSet<BillingCode>();
Set<BillingCode> requestBC = new HashSet<BillingCode>();

sourceBC.add(SeocObjectGenerator.bc1);
sourceBC.add(SeocObjectGenerator.bc2);

requestBC.add(SeocObjectGenerator.bc1);
requestBC.add(SeocObjectGenerator.bc2);

Set<BillingCode> newBC = SeocServiceHelper.findNewBillingCodes(sourceBC, requestBC);

assertThat(newBC).size().isEqualTo(0);
}

/**
* Description: Source set is not empty and request set has one new. The result
* set should have one new billing code in the response one that is new.
*/
@Test
public void findNewBillingCodes_oneNew()
{
Set<BillingCode> sourceBC = new HashSet<BillingCode>();
Set<BillingCode> requestBC = new HashSet<BillingCode>();

sourceBC.add(SeocObjectGenerator.bc1);

requestBC.add(SeocObjectGenerator.bc1);
requestBC.add(SeocObjectGenerator.bc2);

Set<BillingCode> newBC = SeocServiceHelper.findNewBillingCodes(sourceBC, requestBC);
assertThat(newBC).size().isEqualTo(1);
assertThat(newBC).contains(SeocObjectGenerator.bc2);
}

/****** Test cases for findDeletedBillingCodes() ******/

/**
* Description:Request has no billing codes and source has two new billing codes
* check if all the billing codes are identified as deleted billing codes.
*/
@Test
public void findDeletedBillingCodes_deleteAll()
{
Set<BillingCode> requestBC = null;
Set<BillingCode> sourceBC = new HashSet<BillingCode>();

sourceBC.add(SeocObjectGenerator.bc1);
sourceBC.add(SeocObjectGenerator.bc2);

Set<BillingCode> deletedBC = SeocServiceHelper.findDeletedBillingCodes(sourceBC, requestBC);

assertThat(deletedBC).size().isEqualTo(sourceBC.size());
deletedBC.forEach(bc ->
{
assertThat(sourceBC).contains(bc);
});
}

/**
* Description: No change in source and request billing codes. Should return
* empty list.
*/
@Test
public void findDeletedBillingCodes_nothingDeleted()
{
Set<BillingCode> sourceBC = new HashSet<BillingCode>();
Set<BillingCode> requestBC = new HashSet<BillingCode>();

sourceBC.add(SeocObjectGenerator.bc1);
sourceBC.add(SeocObjectGenerator.bc2);

requestBC.add(SeocObjectGenerator.bc1);
requestBC.add(SeocObjectGenerator.bc2);

Set<BillingCode> deletedBC = SeocServiceHelper.findDeletedBillingCodes(sourceBC, requestBC);

assertThat(deletedBC).size().isEqualTo(0);
}

/**
* Description: Source set has two billing codes request set has only of one
* them. The result set should have one billing code in the response that which
* should be deleted.
*/
@Test
public void findDeletedBillingCodes_oneDeleted()
{
Set<BillingCode> sourceBC = new HashSet<BillingCode>();
Set<BillingCode> requestBC = new HashSet<BillingCode>();

sourceBC.add(SeocObjectGenerator.bc1);
sourceBC.add(SeocObjectGenerator.bc2);

requestBC.add(SeocObjectGenerator.bc1);

Set<BillingCode> deletedBC = SeocServiceHelper.findDeletedBillingCodes(sourceBC, requestBC);

assertThat(deletedBC).size().isEqualTo(1);
assertThat(deletedBC).contains(SeocObjectGenerator.bc2);
}

/****** Test cases for syncBillingCodes() ******/

/**
* Description: When there are no billing codes available in the request or
* source. Syncup of billing codes is not required.
*/
@Test
public void syncBillingCodes_noBillingCodes()
{
Set<PayableService> sourceServices = new HashSet<PayableService>();
Set<PayableService> requestServices = new HashSet<PayableService>();

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);
PayableService service2 = SeocObjectGenerator.getPayableService(1, "Test Service2", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, request);

sourceServices.add(service1);

requestServices.add(service2);

Set<BillingCode> updatedBillingCodes = SeocServiceHelper.syncBillingCodes(service1,
service2);

assertThat(updatedBillingCodes).isNull();
}

/**
* Description: Add and Delete billing codes in an existing service
*/
@Test
public void syncBillingCodes_addDelete()
{
Set<BillingCode> sourceBC = new HashSet<BillingCode>();
Set<BillingCode> requestBC = new HashSet<BillingCode>();

BillingCode bc1 = SeocObjectGenerator.bc1;
BillingCode bc2 = SeocObjectGenerator.bc2;
BillingCode bc3 = SeocObjectGenerator.bc3;

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);

if (bc1.getServices() == null)
{
bc1.setServices(new HashSet<PayableService>());
}
bc1.getServices().add(service1);
sourceBC.add(bc1);// To be removed billing code

if (bc3.getServices() == null)
{
bc3.setServices(new HashSet<PayableService>());
}
bc3.getServices().add(service1);
sourceBC.add(bc3);// continuing billing code

service1.setBillingCodes(sourceBC);

PayableService service2 = SeocObjectGenerator.getPayableService(1, "Test Service2", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, request);

if (bc2.getServices() == null)
{
bc2.setServices(new HashSet<PayableService>());
}
bc2.getServices().add(service2);
requestBC.add(bc2);// new billing code

if (bc3.getServices() == null)
{
bc3.setServices(new HashSet<PayableService>());
}
bc3.getServices().add(service2);
requestBC.add(bc3);// continuing billing code

service2.setBillingCodes(requestBC);

assertThat(bc2.getServices()).contains(service2);
assertThat(bc2.getServices()).doesNotContain(service1);
assertThat(bc3.getServices()).contains(service1);
assertThat(bc3.getServices()).contains(service2);
assertThat(sourceBC).contains(bc1);

Set<BillingCode> updatedBillingCodes = SeocServiceHelper.syncBillingCodes(service1,
service2);

assertThat(updatedBillingCodes).size().isEqualTo(2);
assertThat(updatedBillingCodes).contains(bc2);
assertThat(updatedBillingCodes).contains(bc3);
assertThat(updatedBillingCodes).doesNotContain(bc1);

assertThat(sourceBC).doesNotContain(bc1);

}

/****** Test cases for findDeletedServices() ******/

/**
* Description: When the request object is same as the source none of the
* services are deleted
*/
@Test
public void findDeletedServices_noChange()
{
List<PayableService> sourceServices = new ArrayList<PayableService>();
List<PayableService> requestServices = new ArrayList<PayableService>();

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);
PayableService service2 = SeocObjectGenerator.getPayableService(2, "Test Service2", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);

sourceServices.add(service1);
sourceServices.add(service2);

service1.setSeoc(request);
service2.setSeoc(request);
requestServices.add(service1);
requestServices.add(service2);

List<PayableService> deletedServices = SeocServiceHelper.findDeletedServices(sourceServices,
requestServices);

assertThat(deletedServices).size().isEqualTo(0);
}

/**
* Description: Deleting few services from an existing seoc should return the
* servcies which are being deleted.
*/
@Test
public void findDeletedServices_partialDelete()
{
List<PayableService> sourceServices = new ArrayList<PayableService>();
List<PayableService> requestServices = new ArrayList<PayableService>();

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);
PayableService service2 = SeocObjectGenerator.getPayableService(2, "Test Service2", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);

sourceServices.add(service1);
sourceServices.add(service2);

service1.setSeoc(request);
requestServices.add(service1);

List<PayableService> deletedServices = SeocServiceHelper.findDeletedServices(sourceServices,
requestServices);

assertThat(deletedServices).size().isEqualTo(1);
assertThat(deletedServices).contains(service2);
}

/**
* Description: Deleting all services from seoc should return a result set with
* all deleted services.
*/
@Test
public void findDeletedServices_deleteAll()
{
List<PayableService> sourceServices = new ArrayList<PayableService>();
List<PayableService> requestServices = new ArrayList<PayableService>();

Seoc source = new Seoc();
source.setId(1);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);
PayableService service2 = SeocObjectGenerator.getPayableService(2, "Test Service2", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);

sourceServices.add(service1);
sourceServices.add(service2);

List<PayableService> deletedServices = SeocServiceHelper.findDeletedServices(sourceServices,
requestServices);

assertThat(deletedServices).size().isEqualTo(sourceServices.size());
deletedServices.forEach(s ->
{
assertThat(sourceServices).contains(s);
});

}

/**
* Description:Delete Service method is not affecting new service.
*/
@Test
public void findDeletedServices_newServiceUntouched()
{
List<PayableService> sourceServices = new ArrayList<PayableService>();
List<PayableService> requestServices = new ArrayList<PayableService>();

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

// Existing service
PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);
// New Service
PayableService service2 = SeocObjectGenerator.getPayableService(0, "Test Service2", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, request);

sourceServices.add(service1);

service1.setSeoc(request);
requestServices.add(service1);
requestServices.add(service2);

List<PayableService> deletedServices = SeocServiceHelper.findDeletedServices(sourceServices,
requestServices);

assertThat(deletedServices).size().isEqualTo(0);

}

/****** Test cases for syncServices() ******/
/**
* Description: Syncup services method does nothing when there are no services
* in source and request.
*/
@Test
public void syncServices_noServices()
{
Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

List<PayableService> updatedServices = SeocServiceHelper.syncServices(source, request);

assertThat(updatedServices).isEmpty();
}

/**
* Description: Add, Edit and Delete Services
*/
@Test
public void syncServices_addEditDeleteServices()
{
List<PayableService> sourceServices = new ArrayList<PayableService>();
List<PayableService> requestServices = new ArrayList<PayableService>();

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

// New Service
PayableService serviceNew = SeocObjectGenerator.getPayableService(0, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, request);
// Existing service
PayableService serviceEditSource = SeocObjectGenerator.getPayableService(1, "Test Service2",
5, "weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);
PayableService serviceEditRequest = SeocObjectGenerator.getPayableService(1,
"Test Service2", 5, "weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set,
request);
// Tobe deleted Service
PayableService serviceDelete = SeocObjectGenerator.getPayableService(2, "Test Service3", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, source);

BillingCode bc1 = SeocObjectGenerator.bc1;
BillingCode bc2 = SeocObjectGenerator.bc2;
BillingCode bc3 = SeocObjectGenerator.bc3;

Set<BillingCode> billingCodes = new HashSet<BillingCode>();
billingCodes.add(bc1);
billingCodes.add(bc2);

serviceEditSource.setSeoc(source);
serviceEditSource.setBillingCodes(billingCodes);
sourceServices.add(serviceEditSource);

// Request has additional billing code
serviceEditRequest.setSeoc(request);
billingCodes.add(bc3);
serviceEditRequest.setBillingCodes(billingCodes);
requestServices.add(serviceEditRequest);

sourceServices.add(serviceDelete);
serviceDelete.setSeoc(source);

requestServices.add(serviceNew);
billingCodes = new HashSet<BillingCode>();
billingCodes.add(bc1);
serviceNew.setSeoc(request);
serviceNew.setBillingCodes(billingCodes);

source.setServices(sourceServices);
request.setServices(requestServices);

List<PayableService> updatedServices = SeocServiceHelper.syncServices(source, request);

assertThat(updatedServices).contains(serviceEditSource);
assertThat(serviceEditSource.getBillingCodes()).contains(bc3);
assertThat(updatedServices).contains(serviceNew);
assertThat(updatedServices).doesNotContain(serviceDelete);

}

/**
* Description: Check validation of Seoc for Activation, when the constraints
* are not satisfied
*/
@Test(expected = SeocConstraintViolationException.class)
public void validateSeocForActivation_failure()
{
Seoc seoc1 = SeocObjectGenerator.getSeoc(1, "Test", 1, null, null, null, "disclaimer", 0,
"Description", true, "ProceduralOverview", 5, null, null, null, null,
SeocObjectGenerator.cc1, SeocObjectGenerator.sl1, SeocObjectGenerator.inprogress, null,
null);
seoc1.setServices(new ArrayList<PayableService>());

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, seoc1);
PayableService service2 = SeocObjectGenerator.getPayableService(1, "Test Service2", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, seoc1);

seoc1.getServices().add(service1);
seoc1.getServices().add(service2);

SeocServiceHelper.validateSeocForActivation(seoc1, SeocObjectGenerator.inprogress, SeocObjectGenerator.datehold);
}

/**
* Description: Check validation of Seoc for Activation, when the constraints
* are not satisfied
*/
@Test(expected = SeocConstraintViolationException.class)
public void validateSeocForActivation_failureCodeReqYESBillingCodesMissing()
{
Seoc seoc1 = SeocObjectGenerator.getSeoc(1, "Test", 1, null, null, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null,
SeocObjectGenerator.cc1, SeocObjectGenerator.sl1, SeocObjectGenerator.inprogress, SeocObjectGenerator.qasp1,
null);
seoc1.setServices(new ArrayList<PayableService>());
Set<Hptc> hptcs = new HashSet<Hptc>();
hptcs.add(SeocObjectGenerator.hptc1);
seoc1.setHptcs(hptcs);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, seoc1);
PayableService service2 = SeocObjectGenerator.getPayableService(1, "Test Service2", 5,
"weeks", 5, "YES", null, null, SeocObjectGenerator.cs1Set, seoc1);

seoc1.getServices().add(service1);
seoc1.getServices().add(service2);

SeocServiceHelper.validateSeocForActivation(seoc1, SeocObjectGenerator.inprogress, SeocObjectGenerator.datehold);
}

/**
* Description: Check validation of Seoc for Activation, when the constraints
* are not satisfied
*/
@Test(expected = SeocConstraintViolationException.class)
public void validateSeocForActivation_failureCodeReqNOANYBillingCodesAvailable()
{
Seoc seoc1 = SeocObjectGenerator.getSeoc(1, "Test", 1, null, null, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null,
SeocObjectGenerator.cc1, SeocObjectGenerator.sl1, SeocObjectGenerator.inprogress, SeocObjectGenerator.qasp1,
null);
seoc1.setServices(new ArrayList<PayableService>());
Set<Hptc> hptcs = new HashSet<Hptc>();
hptcs.add(SeocObjectGenerator.hptc1);
seoc1.setHptcs(hptcs);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, SeocObjectGenerator.cs1Set, seoc1);

BillingCode bc1 = SeocObjectGenerator.bc1;
BillingCode bc2 = SeocObjectGenerator.bc2;

Set<BillingCode> billingCodes = new HashSet<BillingCode>();
billingCodes.add(bc1);
billingCodes.add(bc2);

service1.setBillingCodes(billingCodes);
seoc1.getServices().add(service1);

SeocServiceHelper.validateSeocForActivation(seoc1, SeocObjectGenerator.inprogress, SeocObjectGenerator.datehold);
}


/**
* Description: versionNumber successfully split into 3 parts
*/
@Test
public void getPartsOfVersion_success()
{
String version = "1.1.2";

String[] parts = SeocServiceHelper.getPartsOfVersion(version);
assertThat(parts).isNotEmpty();
assertThat(parts[0]).isEqualTo("1");
assertThat(parts[1]).isEqualTo("1");
assertThat(parts[2]).isEqualTo("2");

}

/**
* Description: versionNumber in incorrect format will result in null
*/
@Test
public void getPartsOfVersion_failure()
{
String version = "112";

String[] parts = SeocServiceHelper.getPartsOfVersion(version);
assertThat(parts).isNull();

}

@Test
public void unpadEtag_withAdditionalChars()
{
String eTag = "\"ebd8760d1d4f688da7a0fb6ef67e25ef\"";
String trueValue = SeocServiceHelper.unpadEtag(eTag);
assertThat(trueValue).isEqualTo("ebd8760d1d4f688da7a0fb6ef67e25ef");

}

@Test
public void unpadEtag_withNoAdditionalChars()
{
String eTag = "ebd8760d1d4f688da7a0fb6ef67e25ef";
String trueValue = SeocServiceHelper.unpadEtag(eTag);
assertThat(trueValue).isEqualTo("ebd8760d1d4f688da7a0fb6ef67e25ef");

}

/**
* Description: Source has not Hptcs. New Hptcs are added in the request. Assert
* that findNewHptcs() method is identifying them as new Hptcs.
*/
@Test
public void findNewHptcs_allnew()
{
Set<Hptc> sourceHptcs = null;
Set<Hptc> requestHptcs = new HashSet<Hptc>();

requestHptcs.add(SeocObjectGenerator.hptc1);
requestHptcs.add(SeocObjectGenerator.hptc2);

Set<Hptc> actualHptcs = SeocServiceHelper.findNewHptcs(sourceHptcs, requestHptcs);

assertThat(actualHptcs).size().isEqualTo(requestHptcs.size());
assertThat(actualHptcs).containsAll(requestHptcs);
}

/**
* Description: Request has no new Hptcs and no change in expected Hptcs
*/
@Test
public void findNewHptcs_noChange()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> requestHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);
sourceHptcs.add(SeocObjectGenerator.hptc2);

requestHptcs.add(SeocObjectGenerator.hptc1);
requestHptcs.add(SeocObjectGenerator.hptc2);

Set<Hptc> newHptcs = SeocServiceHelper.findNewHptcs(sourceHptcs, requestHptcs);

assertThat(newHptcs).size().isEqualTo(0);
}

/**
* Description: Add new Hptc and duplicate Hptc. findNewHptcs() should identify
* the newly added Hptc only and should not consider duplicate as a new Hptc.
*/
@Test
public void findNewHptcs_addNewAndDuplicate()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> requestHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);

requestHptcs.add(SeocObjectGenerator.hptc1);
requestHptcs.add(SeocObjectGenerator.hptc2);

Set<Hptc> newHptcs = SeocServiceHelper.findNewHptcs(sourceHptcs, requestHptcs);
assertThat(newHptcs).size().isEqualTo(1);
assertThat(newHptcs).contains(SeocObjectGenerator.hptc2);
}

/**
* Description: No new Hptcs. Response from syncHptcs() is empty
*/
@Test
public void syncHptcs_noNewHptcs()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> reqHptcs = new HashSet<Hptc>();

Seoc source = new Seoc();
source.setId(1);
source.setHptcs(sourceHptcs);

Seoc request = new Seoc();
request.setId(1);
request.setHptcs(reqHptcs);

Set<Hptc> expectedHptcs = SeocServiceHelper.syncHptcs(source, request);

assertThat(expectedHptcs).isEmpty();
}

/**
* Description: Existing Hptc in the source and new Hptc in the request.
* Response from syncHptcs() has old and new Hptcs.
*/
@Test
public void syncHptcs_AddNew()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> reqHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);

reqHptcs.add(SeocObjectGenerator.hptc1);
reqHptcs.add(SeocObjectGenerator.hptc2);

Seoc source = new Seoc();
source.setId(1);
source.setHptcs(sourceHptcs);

Seoc request = new Seoc();
request.setId(1);
request.setHptcs(reqHptcs);

Set<Hptc> expectedHptcs = SeocServiceHelper.syncHptcs(source, request);

assertThat(expectedHptcs.size()).isEqualTo(2);
assertThat(expectedHptcs).containsAll(reqHptcs);

}

/**
* Description: Source has existing Hptcs. Request has only one Hptc. Response
* from syncHptcs() matches the request.
*/
@Test
public void syncHptcs_delete()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> reqHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);
sourceHptcs.add(SeocObjectGenerator.hptc2);

reqHptcs.add(SeocObjectGenerator.hptc1);

Seoc source = new Seoc();
source.setId(1);
source.setHptcs(sourceHptcs);

Seoc request = new Seoc();
request.setId(1);
request.setHptcs(reqHptcs);

Set<Hptc> expectedHptcs = SeocServiceHelper.syncHptcs(source, request);

assertThat(expectedHptcs.size()).isEqualTo(1);
assertThat(expectedHptcs).containsAll(reqHptcs);

}

/**
* Description: Source has existing Hptcs. Request has no Hptcs. Expected result
* has no Hptcs.
*/
@Test
public void syncHptcs_deleteAll()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> reqHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);
sourceHptcs.add(SeocObjectGenerator.hptc2);

Seoc source = new Seoc();
source.setId(1);
source.setHptcs(sourceHptcs);

Seoc request = new Seoc();
request.setId(1);
request.setHptcs(reqHptcs);

Set<Hptc> expectedHptcs = SeocServiceHelper.syncHptcs(source, request);

assertThat(expectedHptcs.size()).isEqualTo(0);
assertThat(expectedHptcs).containsAll(reqHptcs);

}

/**
* Description:Request has no new hptcs and source has two new hptcs check if
* all hptcs are identified as deleted hptcs.
*/
@Test
public void findDeletedHptcs_deleteAll()
{
Set<Hptc> requestHptcs = null;
Set<Hptc> sourceHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);
sourceHptcs.add(SeocObjectGenerator.hptc2);

Set<Hptc> deletedHptcs = SeocServiceHelper.findDeletedHptcs(sourceHptcs, requestHptcs);

assertThat(deletedHptcs).size().isEqualTo(sourceHptcs.size());
deletedHptcs.forEach(hptc ->
{
assertThat(sourceHptcs).contains(hptc);
});
}

/**
* Description: No change in source and request hptcs. Should return empty list.
*/
@Test
public void findDeletedHptcs_nothingDeleted()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> requestHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);
sourceHptcs.add(SeocObjectGenerator.hptc2);

requestHptcs.add(SeocObjectGenerator.hptc1);
requestHptcs.add(SeocObjectGenerator.hptc2);

Set<Hptc> deletedHptcs = SeocServiceHelper.findDeletedHptcs(sourceHptcs, requestHptcs);

assertThat(deletedHptcs).size().isEqualTo(0);
}

/**
* Description: Source set has two hptcs request set has only of one them. The
* result set should have one hptc in the response that which should be deleted.
*/
@Test
public void findDeletedHptcs_deleted()
{
Set<Hptc> sourceHptcs = new HashSet<Hptc>();
Set<Hptc> requestHptcs = new HashSet<Hptc>();

sourceHptcs.add(SeocObjectGenerator.hptc1);
sourceHptcs.add(SeocObjectGenerator.hptc2);

requestHptcs.add(SeocObjectGenerator.hptc1);

Set<Hptc> deletedHptcs = SeocServiceHelper.findDeletedHptcs(sourceHptcs, requestHptcs);

assertThat(deletedHptcs).size().isEqualTo(1);
assertThat(deletedHptcs).contains(SeocObjectGenerator.hptc2);
}

@Test
public void findDeletedCSs_deleteAll()
{
Set<ClinicalService> requestCSs = null;
Set<ClinicalService> sourceCSs = new HashSet<ClinicalService>();

sourceCSs.add(SeocObjectGenerator.cs1);
sourceCSs.add(SeocObjectGenerator.cs2);

Set<ClinicalService> deletedCSs = SeocServiceHelper.findDeletedClinicalServices(sourceCSs, requestCSs);

assertThat(deletedCSs).size().isEqualTo(sourceCSs.size());
deletedCSs.forEach(hptc ->
{
assertThat(sourceCSs).contains(hptc);
});
}

@Test
public void findDeletedCSs_nothingDeleted()
{
Set<ClinicalService> requestCSs = new HashSet<ClinicalService>();
Set<ClinicalService> sourceCSs = new HashSet<ClinicalService>();

sourceCSs.add(SeocObjectGenerator.cs1);
sourceCSs.add(SeocObjectGenerator.cs2);

requestCSs.add(SeocObjectGenerator.cs1);
requestCSs.add(SeocObjectGenerator.cs2);

Set<ClinicalService> deletedCSs = SeocServiceHelper.findDeletedClinicalServices(sourceCSs, requestCSs);

assertThat(deletedCSs).size().isEqualTo(0);
}

@Test
public void findDeletedCSs_deleted()
{
Set<ClinicalService> requestCSs = new HashSet<ClinicalService>();
Set<ClinicalService> sourceCSs = new HashSet<ClinicalService>();

sourceCSs.add(SeocObjectGenerator.cs1);
sourceCSs.add(SeocObjectGenerator.cs2);

requestCSs.add(SeocObjectGenerator.cs1);

Set<ClinicalService> deletedCSs = SeocServiceHelper.findDeletedClinicalServices(sourceCSs, requestCSs);

assertThat(deletedCSs).size().isEqualTo(1);
assertThat(deletedCSs).contains(SeocObjectGenerator.cs2);
}

/**
* Description: Source has no clinical services and request has two new billing
* codes check if all the clinical services are identified as new clinical services.
*/
@Test
public void findNewClinicalServices_allnew()
{
Set<ClinicalService> sourceCS = null;
Set<ClinicalService> requestCS = new HashSet<ClinicalService>();

requestCS.add(SeocObjectGenerator.cs1);
requestCS.add(SeocObjectGenerator.cs2);

Set<ClinicalService> newCS = SeocServiceHelper.findNewClinicalServices(sourceCS, requestCS);

assertThat(newCS).size().isEqualTo(requestCS.size());
newCS.forEach(cs ->
{
assertThat(requestCS).contains(cs);
});
}

/**
* Description: No change in source and request clinical services. Should return
* empty list.
*/
@Test
public void findNewClinicalServices_nothingNew()
{
Set<ClinicalService> sourceCS = new HashSet<ClinicalService>();
Set<ClinicalService> requestCS = new HashSet<ClinicalService>();

sourceCS.add(SeocObjectGenerator.cs1);
sourceCS.add(SeocObjectGenerator.cs2);

requestCS.add(SeocObjectGenerator.cs1);
requestCS.add(SeocObjectGenerator.cs2);

Set<ClinicalService> newCS = SeocServiceHelper.findNewClinicalServices(sourceCS, requestCS);

assertThat(newCS).size().isEqualTo(0);
}

/**
* Description: Source set is not empty and request set has one new. The result
* set should have one new clinical service in the response one that is new.
*/
@Test
public void findNewClinicalServices_oneNew()
{
Set<ClinicalService> sourceCS = new HashSet<ClinicalService>();
Set<ClinicalService> requestCS = new HashSet<ClinicalService>();

sourceCS.add(SeocObjectGenerator.cs1);

requestCS.add(SeocObjectGenerator.cs1);
requestCS.add(SeocObjectGenerator.cs2);

Set<ClinicalService> newCS = SeocServiceHelper.findNewClinicalServices(sourceCS, requestCS);

assertThat(newCS).size().isEqualTo(1);
assertThat(newCS).contains(SeocObjectGenerator.cs2);
}


/**
* Description: When there are no clinical service available in the request or
* source. Sync up of clinical services is not required.
*/
@Test
public void syncClinicalServices_noCS()
{
Set<PayableService> sourceServices = new HashSet<PayableService>();
Set<PayableService> requestServices = new HashSet<PayableService>();

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null, null, source);
PayableService service2 = SeocObjectGenerator.getPayableService(1, "Test Service2", 5,
"weeks", 5, "ANY", null, null, null, request);

sourceServices.add(service1);

requestServices.add(service2);

Set<ClinicalService> updatedClinicalServices = SeocServiceHelper.syncClinicalServices(service1,
service2);

assertThat(updatedClinicalServices).isNull();
}

/**
* Description: Add and Delete clinical services in an existing service
*/
@Test
public void syncClinicalServices_addDelete()
{
Set<ClinicalService> sourceCS = new HashSet<ClinicalService>();
Set<ClinicalService> requestCS = new HashSet<ClinicalService>();

ClinicalService cs1 = SeocObjectGenerator.cs1;
ClinicalService cs2 = SeocObjectGenerator.cs2;
ClinicalService cs3 = SeocObjectGenerator.cs3;

Seoc source = new Seoc();
source.setId(1);

Seoc request = new Seoc();
source.setId(1);

PayableService service1 = SeocObjectGenerator.getPayableService(1, "Test Service1", 5,
"weeks", 5, "ANY", null, null,null, source);

if (cs1.getServices() == null)
{
cs1.setServices(new HashSet<PayableService>());
}
cs1.getServices().add(service1);
sourceCS.add(cs1);// To be removed clinical service

if (cs3.getServices() == null)
{
cs3.setServices(new HashSet<PayableService>());
}
cs3.getServices().add(service1);
sourceCS.add(cs3);// continuing clinical service

service1.setClinicalServices(sourceCS);

PayableService service2 = SeocObjectGenerator.getPayableService(1, "Test Service2", 5,
"weeks", 5, "ANY", null, null, null, request);

if (cs2.getServices() == null)
{
cs2.setServices(new HashSet<PayableService>());
}
cs2.getServices().add(service2);
requestCS.add(cs2);// new clinical service

if (cs3.getServices() == null)
{
cs3.setServices(new HashSet<PayableService>());
}
cs3.getServices().add(service2);
requestCS.add(cs3);// continuing clinical service

service2.setClinicalServices(requestCS);

assertThat(cs2.getServices()).contains(service2);
assertThat(cs2.getServices()).doesNotContain(service1);
assertThat(cs3.getServices()).contains(service1);
assertThat(cs3.getServices()).contains(service2);
assertThat(sourceCS).contains(cs1);

Set<ClinicalService> updatedClinicalServices = SeocServiceHelper.syncClinicalServices(service1,
service2);

assertThat(updatedClinicalServices).size().isEqualTo(2);
assertThat(updatedClinicalServices).contains(cs2);
assertThat(updatedClinicalServices).contains(cs3);
assertThat(updatedClinicalServices).doesNotContain(cs1);

assertThat(sourceCS).doesNotContain(cs1);

}

@Test
public void sortBySeocKeyEffectiveDate_keySort()
{
Date activationDate1 = ApiUtil.getUTCZoneDateTime("09-05-2018 05:01:00 AM");
Date activationDate2 = ApiUtil.getUTCZoneDateTime("09-07-2018 05:01:00 AM");
Date activationDate3 = ApiUtil.getUTCZoneDateTime("09-09-2018 05:01:00 AM");

Seoc seoc1 = SeocObjectGenerator.getSeoc(1, "Test", 2, "1.2.2", activationDate3, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Seoc seoc2 = SeocObjectGenerator.getSeoc(2, "Test", 4, "1.2.2", activationDate2, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Seoc seoc3 = SeocObjectGenerator.getSeoc(3, "Test", 3, "1.2.2", activationDate1, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Seoc seoc4 = SeocObjectGenerator.getSeoc(4, "Test", 3, "1.2.2", activationDate3, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Set<Seoc> seocSet = new HashSet<Seoc>();
seocSet.add(seoc1);
seocSet.add(seoc2);
seocSet.add(seoc3);
seocSet.add(seoc4);

List<Seoc> seocSortedList = SeocServiceHelper.sortBySeocKeyEffectiveDate(seocSet);
assertThat(seocSortedList).containsSequence(seoc1,seoc4,seoc3,seoc2);
}

@Test
public void sortBySeocKeyEffectiveDate_effectiveDateSort()
{
Date activationDate1 = ApiUtil.getUTCZoneDateTime("09-05-2018 05:01:00 AM");
Date activationDate2 = ApiUtil.getUTCZoneDateTime("09-07-2018 05:01:00 AM");

Seoc seoc1 = SeocObjectGenerator.getSeoc(1, "Test", 2, "1.2.2", activationDate1, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Seoc seoc2 = SeocObjectGenerator.getSeoc(2, "Test", 2, "1.2.2", activationDate2, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Seoc seoc3 = SeocObjectGenerator.getSeoc(3, "Test", 3, "1.2.2", activationDate2, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Seoc seoc4 = SeocObjectGenerator.getSeoc(4, "Test", 3, "1.2.2", activationDate1, null, "disclaimer", 5,
"Description", true, "ProceduralOverview", 5, null, null, null, null, SeocObjectGenerator.cc1,
SeocObjectGenerator.sl1, dateHold, null, null);

Set<Seoc> seocSet = new HashSet<Seoc>();
seocSet.add(seoc1);
seocSet.add(seoc2);
seocSet.add(seoc3);
seocSet.add(seoc4);

List<Seoc> seocSortedList = SeocServiceHelper.sortBySeocKeyEffectiveDate(seocSet);
assertThat(seocSortedList).containsSequence(seoc2,seoc1,seoc3,seoc4);
}

}