summaryrefslogtreecommitdiffstats
path: root/main/src/test/java/org
diff options
context:
space:
mode:
Diffstat (limited to 'main/src/test/java/org')
-rw-r--r--main/src/test/java/org/onap/policy/pap/main/rest/depundep/ProviderSuper.java29
-rw-r--r--main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestGroupData.java97
-rw-r--r--main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestPdpGroupDeployProvider.java4
-rw-r--r--main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestProviderBase.java28
-rw-r--r--main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestSessionData.java210
5 files changed, 302 insertions, 66 deletions
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/ProviderSuper.java b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/ProviderSuper.java
index 3a3673d5..a1e69565 100644
--- a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/ProviderSuper.java
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/ProviderSuper.java
@@ -29,6 +29,7 @@ import static org.mockito.Mockito.when;
import java.io.File;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.List;
import org.junit.Before;
import org.mockito.ArgumentCaptor;
@@ -125,27 +126,25 @@ public class ProviderSuper {
/**
* Gets the input to the method.
*
- * @param count the number of times the method is expected to have been called.
* @return the input that was passed to the dao.createPdpGroups() method
* @throws Exception if an error occurred
*/
- protected List<List<PdpGroup>> getGroupCreates(int count) throws Exception {
- verify(dao, times(count)).createPdpGroups(createCaptor.capture());
+ protected List<PdpGroup> getGroupCreates() throws Exception {
+ verify(dao).createPdpGroups(createCaptor.capture());
- return copyLists(createCaptor.getAllValues());
+ return copyList(createCaptor.getValue());
}
/**
* Gets the input to the method.
*
- * @param count the number of times the method is expected to have been called
* @return the input that was passed to the dao.updatePdpGroups() method
* @throws Exception if an error occurred
*/
- protected List<List<PdpGroup>> getGroupUpdates(int count) throws Exception {
- verify(dao, times(count)).updatePdpGroups(updateCaptor.capture());
+ protected List<PdpGroup> getGroupUpdates() throws Exception {
+ verify(dao).updatePdpGroups(updateCaptor.capture());
- return copyLists(updateCaptor.getAllValues());
+ return copyList(updateCaptor.getValue());
}
/**
@@ -163,19 +162,15 @@ public class ProviderSuper {
}
/**
- * Makes a partly deep copy of the list.
+ * Copies a list and sorts it by group name.
*
* @param source source list to copy
* @return a copy of the source list
*/
- private List<List<PdpGroup>> copyLists(List<List<PdpGroup>> source) {
- List<List<PdpGroup>> target = new ArrayList<>(source.size());
-
- for (List<PdpGroup> lst : source) {
- target.add(new ArrayList<>(lst));
- }
-
- return target;
+ private List<PdpGroup> copyList(List<PdpGroup> source) {
+ List<PdpGroup> newlst = new ArrayList<>(source);
+ Collections.sort(newlst, (left, right) -> left.getName().compareTo(right.getName()));
+ return newlst;
}
/**
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestGroupData.java b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestGroupData.java
new file mode 100644
index 00000000..a0d4989f
--- /dev/null
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestGroupData.java
@@ -0,0 +1,97 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP PAP
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.pap.main.rest.depundep;
+
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.common.utils.validation.Version;
+import org.onap.policy.models.pdp.concepts.PdpGroup;
+
+public class TestGroupData {
+ private static final String NEW_VERSION = "2.0.0";
+ private static final String NAME = "my-name";
+
+ private PdpGroup oldGroup;
+ private PdpGroup newGroup;
+ private GroupData data;
+ private Version version;
+
+ /**
+ * Sets up.
+ */
+ @Before
+ public void setUp() {
+ oldGroup = new PdpGroup();
+ oldGroup.setName(NAME);
+
+ newGroup = new PdpGroup(oldGroup);
+
+ version = new Version(1, 2, 3);
+
+ data = new GroupData(oldGroup);
+ }
+
+ @Test
+ public void test() {
+ assertFalse(data.isNew());
+ assertSame(oldGroup, data.getOldGroup());
+ assertSame(oldGroup, data.getCurrentGroup());
+
+ data.setLatestVersion(version);
+ data.setNewGroup(newGroup);
+
+ assertTrue(data.isNew());
+ assertSame(oldGroup, data.getOldGroup());
+ assertSame(newGroup, data.getCurrentGroup());
+ assertEquals(NEW_VERSION, data.getLatestVersion().toString());
+ assertEquals(NEW_VERSION, newGroup.getVersion());
+
+ // repeat
+ newGroup = new PdpGroup(oldGroup);
+ data.setNewGroup(newGroup);
+ assertSame(oldGroup, data.getOldGroup());
+ assertSame(newGroup, data.getCurrentGroup());
+ assertEquals(NEW_VERSION, data.getLatestVersion().toString());
+ assertEquals(NEW_VERSION, newGroup.getVersion());
+ }
+
+ @Test
+ public void testSetNewGroup_DifferentName() {
+ newGroup.setName("different-name");
+
+ data.setLatestVersion(version);
+ assertThatIllegalArgumentException().isThrownBy(() -> data.setNewGroup(newGroup))
+ .withMessage("attempt to change group name from my-name to different-name");
+ }
+
+ @Test
+ public void testSetNewGroup_VersionNotSet() {
+ assertThatIllegalStateException().isThrownBy(() -> data.setNewGroup(newGroup))
+ .withMessage("latestVersion not set for group: my-name");
+ }
+}
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestPdpGroupDeployProvider.java b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestPdpGroupDeployProvider.java
index d3ffda84..018f117c 100644
--- a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestPdpGroupDeployProvider.java
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestPdpGroupDeployProvider.java
@@ -149,8 +149,8 @@ public class TestPdpGroupDeployProvider extends ProviderSuper {
assertEquals(Status.OK, pair.getLeft());
assertNull(pair.getRight().getErrorDetails());
- assertGroup(getGroupUpdates(1).get(0), GROUP1_NAME, GROUP1_VERSION);
- assertGroup(getGroupCreates(1).get(0), GROUP1_NAME, GROUP1_NEW_VERSION);
+ assertGroup(getGroupUpdates(), GROUP1_NAME, GROUP1_VERSION);
+ assertGroup(getGroupCreates(), GROUP1_NAME, GROUP1_NEW_VERSION);
List<PdpUpdate> requests = getUpdateRequests(2);
assertUpdate(requests, GROUP1_NAME, PDP2_TYPE, PDP2);
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestProviderBase.java b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestProviderBase.java
index f64f77da..883b3d55 100644
--- a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestProviderBase.java
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestProviderBase.java
@@ -109,8 +109,8 @@ public class TestProviderBase extends ProviderSuper {
assertEquals(Status.OK, pair.getLeft());
assertNull(pair.getRight().getErrorDetails());
- assertGroup(getGroupUpdates(1).get(0), GROUP1_NAME, GROUP1_VERSION);
- assertGroup(getGroupCreates(1).get(0), GROUP1_NAME, GROUP1_NEW_VERSION);
+ assertGroup(getGroupUpdates(), GROUP1_NAME, GROUP1_VERSION);
+ assertGroup(getGroupCreates(), GROUP1_NAME, GROUP1_NEW_VERSION);
assertUpdate(getUpdateRequests(1), GROUP1_NAME, PDP1_TYPE, PDP1);
}
@@ -197,8 +197,8 @@ public class TestProviderBase extends ProviderSuper {
assertEquals(Status.OK, pair.getLeft());
assertNull(pair.getRight().getErrorDetails());
- assertGroup(getGroupUpdates(1).get(0), GROUP1_NAME, GROUP1_VERSION);
- assertGroup(getGroupCreates(1).get(0), GROUP1_NAME, GROUP1_NEW_VERSION);
+ assertGroup(getGroupUpdates(), GROUP1_NAME, GROUP1_VERSION);
+ assertGroup(getGroupCreates(), GROUP1_NAME, GROUP1_NEW_VERSION);
}
@Test
@@ -224,8 +224,8 @@ public class TestProviderBase extends ProviderSuper {
assertEquals(Status.OK, pair.getLeft());
assertNull(pair.getRight().getErrorDetails());
- assertGroup(getGroupUpdates(1).get(0), GROUP1_NAME, GROUP1_VERSION);
- assertGroup(getGroupCreates(1).get(0), GROUP1_NAME, GROUP1_NEW_VERSION);
+ assertGroup(getGroupUpdates(), GROUP1_NAME, GROUP1_VERSION);
+ assertGroup(getGroupCreates(), GROUP1_NAME, GROUP1_NEW_VERSION);
List<PdpUpdate> requests = getUpdateRequests(2);
assertUpdate(requests, GROUP1_NAME, PDP2_TYPE, PDP2);
@@ -282,15 +282,15 @@ public class TestProviderBase extends ProviderSuper {
assertEquals(Status.OK, pair.getLeft());
assertNull(pair.getRight().getErrorDetails());
- List<List<PdpGroup>> creates = getGroupCreates(2);
- assertGroup(creates.get(0), GROUP1_NAME, GROUP1_NEW_VERSION);
- assertGroup(creates.get(1), GROUP2_NAME, "301.0.0");
+ // verify creates
+ List<PdpGroup> changes = getGroupCreates();
+ assertGroup(changes, GROUP1_NAME, GROUP1_NEW_VERSION);
+ assertGroup(changes, GROUP2_NAME, "301.0.0");
- List<List<PdpGroup>> updates = getGroupUpdates(4);
- assertGroup(updates.get(0), GROUP1_NAME, GROUP1_VERSION);
- assertGroup(updates.get(1), GROUP2_NAME, "300.2.3");
- assertGroup(updates.get(2), GROUP1_NAME, GROUP1_NEW_VERSION);
- assertGroup(updates.get(3), GROUP1_NAME, GROUP1_NEW_VERSION);
+ // verify updates
+ changes = getGroupUpdates();
+ assertGroup(changes, GROUP1_NAME, GROUP1_VERSION);
+ assertGroup(changes, GROUP2_NAME, "300.2.3");
List<PdpUpdate> requests = getUpdateRequests(3);
assertUpdateIgnorePolicy(requests, GROUP1_NAME, PDP1_TYPE, PDP1);
diff --git a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestSessionData.java b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestSessionData.java
index 6be5c8ac..1c2b8233 100644
--- a/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestSessionData.java
+++ b/main/src/test/java/org/onap/policy/pap/main/rest/depundep/TestSessionData.java
@@ -20,12 +20,14 @@
package org.onap.policy.pap.main.rest.depundep;
+import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -49,9 +51,10 @@ import org.onap.policy.pap.main.PolicyPapRuntimeException;
public class TestSessionData extends ProviderSuper {
private static final String GROUP_VERSION_PREFIX = "9.8.";
- private static final String GROUP_NAME = "group";
+ private static final String GROUP_NAME = "groupA";
private static final String GROUP_VERSION = GROUP_VERSION_PREFIX + "7";
- private static final String GROUP_NAME2 = "group2";
+ private static final String GROUP_NEW_VERSION = "10.0.0";
+ private static final String GROUP_NAME2 = "groupB";
private static final String GROUP_VERSION2 = GROUP_VERSION_PREFIX + "6";
private static final String PDP1 = "pdp_1";
private static final String PDP2 = "pdp_2";
@@ -60,9 +63,15 @@ public class TestSessionData extends ProviderSuper {
private static final String POLICY_NAME = "myPolicy";
private static final String POLICY_VERSION = POLICY_VERSION_PREFIX + "3";
private static final String POLICY_VERSION2 = POLICY_VERSION_PREFIX + "4";
+ private static final String POLICY_TYPE = "myType";
+ private static final String POLICY_TYPE_VERSION = "10.20.30";
private SessionData session;
private ToscaPolicyIdentifier ident;
+ private ToscaPolicyTypeIdentifier type;
+ private ToscaPolicyTypeIdentifier type2;
+ private PdpGroup group1;
+ private PdpGroup group2;
/**
* Initializes mocks and a session.
@@ -74,6 +83,10 @@ public class TestSessionData extends ProviderSuper {
super.setUp();
ident = new ToscaPolicyIdentifier(POLICY_NAME, POLICY_VERSION);
+ type = new ToscaPolicyTypeIdentifier(POLICY_TYPE, POLICY_TYPE_VERSION);
+ type2 = new ToscaPolicyTypeIdentifier(POLICY_TYPE, POLICY_TYPE_VERSION + "0");
+ group1 = makeGroup(GROUP_NAME, GROUP_VERSION);
+ group2 = makeGroup(GROUP_NAME2, GROUP_VERSION2);
session = new SessionData(dao);
}
@@ -126,7 +139,7 @@ public class TestSessionData extends ProviderSuper {
}
@Test
- public void testAddUpdate() {
+ public void testAddUpdate_testGetPdpUpdates() {
// several different updates, but one duplicate
PdpUpdate update1 = makeUpdate(PDP1);
session.addUpdate(update1);
@@ -137,14 +150,14 @@ public class TestSessionData extends ProviderSuper {
PdpUpdate update3 = makeUpdate(PDP3);
session.addUpdate(update3);
- List<PdpUpdate> lst = sort(session.getUpdates(), this::compare);
+ List<PdpUpdate> lst = sort(session.getPdpUpdates(), this::compare);
assertEquals(Arrays.asList(update1, update2, update3).toString(), lst.toString());
// overwrite one
update2 = makeUpdate(PDP2);
session.addUpdate(update2);
- lst = sort(session.getUpdates(), this::compare);
+ lst = sort(session.getPdpUpdates(), this::compare);
assertEquals(Arrays.asList(update1, update2, update3).toString(), lst.toString());
}
@@ -164,8 +177,15 @@ public class TestSessionData extends ProviderSuper {
when(dao.getFilteredPolicyList(any())).thenReturn(Arrays.asList(policy1));
assertSame(policy1, session.getPolicyMaxVersion(POLICY_NAME));
+ assertSame(policy1, session.getPolicyMaxVersion(POLICY_NAME));
+ assertSame(policy1, session.getPolicyMaxVersion(POLICY_NAME));
+
+ // should have only invoked DAO once; used cache for other requests
+ verify(dao, times(1)).getFilteredPolicyList(any());
+ }
- // no matching policies - should throw an exception
+ @Test
+ public void testGetPolicyMaxVersion_NotFound() throws Exception {
when(dao.getFilteredPolicyList(any())).thenReturn(Collections.emptyList());
assertThatThrownBy(() -> session.getPolicyMaxVersion(POLICY_NAME)).hasMessage("cannot find policy: myPolicy");
}
@@ -174,24 +194,34 @@ public class TestSessionData extends ProviderSuper {
public void testIsNewlyCreated_testCreatePdpGroup() throws Exception {
assertFalse(session.isNewlyCreated(GROUP_NAME));
- PdpGroup group1 = makeGroup(GROUP_NAME, GROUP_VERSION);
- when(dao.createPdpGroups(any())).thenReturn(Arrays.asList(group1));
+ // cause the group to be loaded into the cache
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
+ session.getActivePdpGroupsByPolicyType(type);
- session.createPdpGroup(group1);
+ // not new yet
+ assertFalse(session.isNewlyCreated(GROUP_NAME));
+ // update it
+ session.setNewGroup(new PdpGroup(group1));
assertTrue(session.isNewlyCreated(GROUP_NAME));
- assertFalse(session.isNewlyCreated(GROUP_NAME2));
- PdpGroup group2 = makeGroup(GROUP_NAME2, GROUP_VERSION2);
- when(dao.createPdpGroups(any())).thenReturn(Arrays.asList(group2));
- session.createPdpGroup(group2);
+ /*
+ * now try group2
+ */
+ assertFalse(session.isNewlyCreated(GROUP_NAME2));
- List<List<PdpGroup>> creates = getGroupCreates(2);
- assertEquals(group1, creates.get(0).get(0));
- assertEquals(group2, creates.get(1).get(0));
+ // cause the group to be loaded into the cache
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group2));
+ session.getActivePdpGroupsByPolicyType(type2);
+ // not new yet
+ assertFalse(session.isNewlyCreated(GROUP_NAME2));
assertTrue(session.isNewlyCreated(GROUP_NAME));
+
+ // update it
+ session.setNewGroup(new PdpGroup(group2));
assertTrue(session.isNewlyCreated(GROUP_NAME2));
+ assertTrue(session.isNewlyCreated(GROUP_NAME));
}
private PdpGroup makeGroup(String name, String version) {
@@ -204,37 +234,151 @@ public class TestSessionData extends ProviderSuper {
}
@Test
- public void testGetPdpGroupMaxVersion() throws Exception {
- PdpGroup group = makeGroup(GROUP_NAME, GROUP_VERSION);
- when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group));
+ public void testSetNewGroup() throws Exception {
+ // force the groups into the cache
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1, group2));
+ session.getActivePdpGroupsByPolicyType(type);
+
+ /*
+ * try group 1
+ */
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
+ PdpGroup newgrp = new PdpGroup(group1);
+ session.setNewGroup(newgrp);
+ assertEquals(GROUP_NEW_VERSION, newgrp.getVersion().toString());
+
+ // repeat - version should be unchanged
+ newgrp = new PdpGroup(group1);
+ session.setNewGroup(newgrp);
+ assertEquals(GROUP_NEW_VERSION, newgrp.getVersion().toString());
+
+ /*
+ * try group 2
+ */
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group2));
+ newgrp = new PdpGroup(group2);
+ session.setNewGroup(newgrp);
+ assertEquals(GROUP_NEW_VERSION, newgrp.getVersion().toString());
+
+ // repeat - version should be unchanged
+ newgrp = new PdpGroup(group2);
+ session.setNewGroup(newgrp);
+ assertEquals(GROUP_NEW_VERSION, newgrp.getVersion().toString());
+
+ // should have queried the DB once by type and twice by for latest version
+ verify(dao, times(3)).getFilteredPdpGroups(any());
+ }
+
+ @Test
+ public void testSetNewGroup_NotInCache() throws Exception {
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
- assertEquals(group, session.getPdpGroupMaxVersion(GROUP_NAME));
+ assertThatIllegalStateException().isThrownBy(() -> session.setNewGroup(new PdpGroup(group1)))
+ .withMessage("group not cached: groupA");
+ }
- // try empty list
+ @Test
+ public void testSetNewGroup_NotFound() throws Exception {
+ // force the group into the cache
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
+ session.getActivePdpGroupsByPolicyType(type);
+
+ // query for latest version will return an empty list
when(dao.getFilteredPdpGroups(any())).thenReturn(Collections.emptyList());
- assertThatThrownBy(() -> session.getPdpGroupMaxVersion(GROUP_NAME))
- .isInstanceOf(PolicyPapRuntimeException.class).hasMessage("cannot find group: group");
+
+ assertThatThrownBy(() -> session.setNewGroup(new PdpGroup(group1)))
+ .isInstanceOf(PolicyPapRuntimeException.class).hasMessage("cannot find group: groupA");
+ }
+
+ @Test
+ public void testSetNewGroup_InvalidVersion() throws Exception {
+ // force the groups into the cache
+ group1.setVersion("invalid version");
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
+ session.getActivePdpGroupsByPolicyType(type);
+
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
+ PdpGroup newgrp = new PdpGroup(group1);
+ session.setNewGroup(newgrp);
+ assertEquals("1.0.0", newgrp.getVersion().toString());
}
@Test
public void testGetActivePdpGroupsByPolicyType() throws Exception {
- List<PdpGroup> groups =
- Arrays.asList(makeGroup(GROUP_NAME, GROUP_VERSION), makeGroup(GROUP_NAME2, GROUP_VERSION2));
+ List<PdpGroup> groups = Arrays.asList(group1, group2);
when(dao.getFilteredPdpGroups(any())).thenReturn(groups);
- assertEquals(groups, session
- .getActivePdpGroupsByPolicyType(new ToscaPolicyTypeIdentifier(POLICY_NAME, POLICY_VERSION)));
+ // repeat
+ assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
+ assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
+ assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
+
+ // only invoked once - should have used the cache for the rest
+ verify(dao, times(1)).getFilteredPdpGroups(any());
}
@Test
- public void testUpdatePdpGroup() throws Exception {
- PdpGroup group = makeGroup(GROUP_NAME, GROUP_VERSION);
- when(dao.updatePdpGroups(any())).thenReturn(Arrays.asList(group));
+ public void testAddGroup() throws Exception {
+ List<PdpGroup> groups = Arrays.asList(group1, group2);
+ when(dao.getFilteredPdpGroups(any())).thenReturn(groups);
- session.updatePdpGroup(group);
+ // query by each type
+ assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
+ assertEquals(groups, session.getActivePdpGroupsByPolicyType(type2));
- List<PdpGroup> updates = getGroupUpdates(1).get(0);
- assertEquals(group, updates.get(0));
+ // invoked once for each type
+ verify(dao, times(2)).getFilteredPdpGroups(any());
+
+ // repeat - should be no more invocations
+ assertEquals(groups, session.getActivePdpGroupsByPolicyType(type));
+ assertEquals(groups, session.getActivePdpGroupsByPolicyType(type2));
+ verify(dao, times(2)).getFilteredPdpGroups(any());
+ }
+
+ @Test
+ public void testUpdateDb() throws Exception {
+ // force the groups into the cache
+ PdpGroup group3 = makeGroup("groupC", GROUP_VERSION2);
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1, group2, group3));
+ session.getActivePdpGroupsByPolicyType(type);
+
+ // update group 1
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1));
+ PdpGroup newgrp1 = new PdpGroup(group1);
+ session.setNewGroup(newgrp1);
+
+ // another update
+ newgrp1 = new PdpGroup(newgrp1);
+ session.setNewGroup(newgrp1);
+
+ // update group 3
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group3));
+ PdpGroup newgrp3 = new PdpGroup(group3);
+ session.setNewGroup(newgrp3);
+
+ // push the changes to the DB
+ session.updateDb();
+
+ // expect one create for groups 1 & 3
+ List<PdpGroup> changes = getGroupCreates();
+ assertSame(newgrp1, changes.get(0));
+ assertSame(newgrp3, changes.get(1));
+
+ // expect one update for groups 1 & 3
+ changes = getGroupUpdates();
+ assertSame(group1, changes.get(0));
+ assertSame(group3, changes.get(1));
+ }
+
+ @Test
+ public void testUpdateDb_Empty() throws Exception {
+ // force data into the cache
+ when(dao.getFilteredPdpGroups(any())).thenReturn(Arrays.asList(group1, group2));
+ session.getActivePdpGroupsByPolicyType(type);
+
+ session.updateDb();
+ verify(dao, never()).createPdpGroups(any());
+ verify(dao, never()).updatePdpGroups(any());
}
private PdpUpdate makeUpdate(String pdpName) {