2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.versioning.impl;
23 import static org.mockito.Matchers.any;
24 import static org.mockito.Matchers.eq;
25 import static org.mockito.Mockito.doReturn;
26 import static org.mockito.Mockito.doThrow;
27 import static org.mockito.Mockito.never;
28 import static org.mockito.Mockito.times;
29 import static org.mockito.Mockito.verify;
30 import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.OutOfSync;
31 import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.UpToDate;
32 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
33 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
35 import java.util.ArrayList;
36 import java.util.List;
37 import java.util.Optional;
38 import java.util.stream.Collectors;
39 import java.util.stream.Stream;
40 import org.junit.Assert;
41 import org.junit.Before;
42 import org.junit.Rule;
43 import org.junit.Test;
44 import org.junit.rules.ExpectedException;
45 import org.mockito.ArgumentCaptor;
46 import org.mockito.InjectMocks;
47 import org.mockito.Mock;
48 import org.mockito.MockitoAnnotations;
49 import org.openecomp.sdc.common.errors.CoreException;
50 import org.openecomp.sdc.versioning.ItemManager;
51 import org.openecomp.sdc.versioning.VersionCalculator;
52 import org.openecomp.sdc.versioning.dao.VersionDao;
53 import org.openecomp.sdc.versioning.dao.types.Revision;
54 import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
55 import org.openecomp.sdc.versioning.dao.types.Version;
56 import org.openecomp.sdc.versioning.dao.types.VersionState;
57 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
58 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
60 public class VersioningManagerImplTest {
61 private static final String ITEM_ID = "itemId";
62 private static final String VERSION_ID = "versionId";
65 public ExpectedException expectedException = ExpectedException.none();
68 private VersionDao versionDaoMock;
70 private VersionCalculator versionCalculatorMock;
72 private ItemManager asdcItemManager;
74 private VersioningManagerImpl versioningManager;
77 public void setUp() throws Exception {
78 MockitoAnnotations.initMocks(this);
82 public void testListWhenNone() {
83 doReturn(new ArrayList<>()).when(versionDaoMock).list(ITEM_ID);
85 List<Version> versions = versioningManager.list(ITEM_ID);
87 Assert.assertTrue(versions.isEmpty());
91 public void testList() {
92 List<Version> returnedVersions = Stream.of(createVersion("1", null, null, false),
93 createVersion("2", null, null, false),
94 createVersion("3", null, null, false)).collect(Collectors.toList());
95 doReturn(returnedVersions).when(versionDaoMock).list(ITEM_ID);
97 List<Version> versions = versioningManager.list(ITEM_ID);
98 Assert.assertEquals(versions, returnedVersions);
101 @Test(expected = Exception.class)
102 public void testGetNonExisting() throws Exception {
103 Version version = new Version(VERSION_ID);
105 doReturn(Optional.empty()).when(versionDaoMock).get(ITEM_ID, version);
106 doThrow(new Exception()).when(versionDaoMock).sync(ITEM_ID, version);
108 versioningManager.get(ITEM_ID, version);
112 public void testGetNonExistingForUser() {
113 Version requestedVersion = new Version(VERSION_ID);
115 Version returnedVersion = createVersion(VERSION_ID, Draft, UpToDate, false);
116 doReturn(Optional.empty()).doReturn(Optional.of(returnedVersion))
117 .when(versionDaoMock).get(ITEM_ID, requestedVersion);
119 Version version = versioningManager.get(ITEM_ID, requestedVersion);
120 Assert.assertEquals(version, returnedVersion);
122 verify(versionDaoMock, times(2)).get(ITEM_ID, requestedVersion);
123 verify(versionDaoMock).sync(ITEM_ID, requestedVersion);
127 public void testGetOutOfSyncCertified() {
128 Version requestedVersion = new Version(VERSION_ID);
130 Version returnedVersion = createVersion(VERSION_ID, Certified, UpToDate, false);
131 doReturn(Optional.of(createVersion(VERSION_ID, Certified, OutOfSync, false)))
132 .doReturn(Optional.of(returnedVersion))
133 .when(versionDaoMock).get(ITEM_ID, requestedVersion);
135 Version version = versioningManager.get(ITEM_ID, requestedVersion);
136 Assert.assertEquals(version, returnedVersion);
138 verify(versionDaoMock, times(2)).get(ITEM_ID, requestedVersion);
139 verify(versionDaoMock).forceSync(ITEM_ID, requestedVersion);
143 public void testGet() {
144 Version requestedVersion = new Version(VERSION_ID);
146 Version returnedVersion = createVersion(VERSION_ID, Draft, OutOfSync, true);
147 doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, requestedVersion);
149 Version version = versioningManager.get(ITEM_ID, requestedVersion);
150 Assert.assertEquals(version, returnedVersion);
152 verify(versionDaoMock).get(ITEM_ID, requestedVersion);
153 verify(versionDaoMock, never()).sync(any(), any());
154 verify(versionDaoMock, never()).forceSync(any(), any());
158 public void testCreate() {
159 Version requestedVersion = new Version();
161 String versionName = "versionName";
162 doReturn(versionName).when(versionCalculatorMock).calculate(null, VersionCreationMethod.major);
164 doReturn(Stream.of(createVersion("1", null, null, false),
165 createVersion("2", null, null, false),
166 createVersion("3", null, null, false)).collect(Collectors.toList()))
167 .when(versionDaoMock).list(ITEM_ID);
170 versioningManager.create(ITEM_ID, requestedVersion, VersionCreationMethod.major);
171 Assert.assertNotNull(version);
172 Assert.assertEquals(version.getName(), versionName);
174 verify(versionDaoMock).create(ITEM_ID, requestedVersion);
175 verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null);
176 verify(versionDaoMock)
177 .publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: versionName"));
181 public void testCreateBasedOn() {
182 Version requestedVersion = new Version();
183 requestedVersion.setBaseId("baseVersionId");
185 Version baseVersion = createVersion(requestedVersion.getBaseId(), Certified, UpToDate, false);
186 // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
187 doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(ITEM_ID), any(Version.class));
189 String versionName = "4.0";
190 doReturn(versionName)
191 .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
193 doReturn(Stream.of(createVersion("1", null, null, false),
194 createVersion("2", null, null, false),
195 createVersion("3", null, null, false)).collect(Collectors.toList()))
196 .when(versionDaoMock).list(ITEM_ID);
199 versioningManager.create(ITEM_ID, requestedVersion, VersionCreationMethod.major);
200 Assert.assertNotNull(version);
201 Assert.assertEquals(version.getName(), versionName);
203 verify(versionDaoMock).create(ITEM_ID, requestedVersion);
204 verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null);
205 verify(versionDaoMock).publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: 4.0"));
209 public void testCreateWithExistingName() {
211 expectedException.expect(CoreException.class);
212 expectedException.expectMessage("Item itemId: create version failed, a version with the name 2.0 already exist");
214 Version version = new Version();
215 version.setBaseId("baseVersionId");
217 Version baseVersion = createVersion(version.getBaseId(), Certified, UpToDate, false);
218 // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
219 doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(ITEM_ID), any(Version.class));
221 String versionName = "2.0";
222 doReturn(versionName)
223 .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
225 doReturn(Stream.of(createVersion("1", null, null, false),
226 createVersion("2", null, null, false),
227 createVersion("3", null, null, false)).collect(Collectors.toList()))
228 .when(versionDaoMock).list(ITEM_ID);
230 versioningManager.create(ITEM_ID, version, VersionCreationMethod.major);
234 public void testSubmitCertified() {
236 expectedException.expect(CoreException.class);
237 expectedException.expectMessage("Item itemId: submit version failed, version versionId is already Certified");
239 Version version = new Version(VERSION_ID);
241 Version returnedVersion = createVersion(VERSION_ID, Certified, UpToDate, false);
242 doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, version);
244 versioningManager.submit(ITEM_ID, version, "Submit message");
248 public void testSubmit() {
249 Version version = new Version(VERSION_ID);
251 ArgumentCaptor<Version> versionArgumentCaptor = ArgumentCaptor.forClass(Version.class);
253 Version returnedVersion = createVersion(VERSION_ID, Draft, UpToDate, false);
254 doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, version);
256 String submitDescription = "Submit message";
257 versioningManager.submit(ITEM_ID, version, submitDescription);
259 verify(versionDaoMock).update(eq(ITEM_ID), versionArgumentCaptor.capture());
260 Assert.assertEquals(Certified, versionArgumentCaptor.getValue().getStatus());
261 verify(versionDaoMock).publish(ITEM_ID, version, submitDescription);
262 verify(asdcItemManager).updateVersionStatus(ITEM_ID, Certified, Draft);
266 public void testPublish() {
267 Version version = new Version(VERSION_ID);
268 String publishDescription = "Publish message";
270 versioningManager.publish(ITEM_ID, version, publishDescription);
272 verify(versionDaoMock).publish(ITEM_ID, version, publishDescription);
276 public void testSync() {
277 Version version = new Version(VERSION_ID);
279 versioningManager.sync(ITEM_ID, version);
281 verify(versionDaoMock).sync(ITEM_ID, version);
285 public void testForceSync() {
286 Version version = new Version(VERSION_ID);
288 versioningManager.forceSync(ITEM_ID, version);
290 verify(versionDaoMock).forceSync(ITEM_ID, version);
294 public void testRevert() {
295 Version version = new Version(VERSION_ID);
296 String revisionId = "revisionId";
298 versioningManager.revert(ITEM_ID, version, revisionId);
300 verify(versionDaoMock).revert(ITEM_ID, version, revisionId);
304 public void testListRevisions() {
305 Version version = new Version(VERSION_ID);
307 List<Revision> returnedRevisions =
308 Stream.of(new Revision(), new Revision()).collect(Collectors.toList());
309 doReturn(returnedRevisions)
310 .when(versionDaoMock).listRevisions(ITEM_ID, version);
312 List<Revision> revisions = versioningManager.listRevisions(ITEM_ID, version);
313 Assert.assertEquals(revisions, returnedRevisions);
316 private Version createVersion(String id, VersionStatus status,
317 SynchronizationState syncState, boolean dirty) {
318 Version version = new Version(id);
319 version.setName(id + ".0");
320 version.setDescription(id + " desc");
321 version.setStatus(status);
323 VersionState state = new VersionState();
324 state.setSynchronizationState(syncState);
325 state.setDirty(dirty);
326 version.setState(state);