001/**
002 * Copyright 2005-2014 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.rice.krms.test;
017
018import org.junit.Before;
019import org.junit.Test;
020import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
021import org.kuali.rice.krad.data.DataObjectService;
022import org.kuali.rice.krms.api.repository.context.ContextDefinition;
023import org.kuali.rice.krms.api.repository.term.TermDefinition;
024import org.kuali.rice.krms.api.repository.term.TermParameterDefinition;
025import org.kuali.rice.krms.api.repository.term.TermResolverDefinition;
026import org.kuali.rice.krms.api.repository.term.TermSpecificationDefinition;
027import org.kuali.rice.krms.api.repository.type.KrmsTypeBoService;
028import org.kuali.rice.krms.api.repository.type.KrmsTypeDefinition;
029import org.kuali.rice.krms.impl.repository.ContextBoService;
030import org.kuali.rice.krms.impl.repository.ContextBoServiceImpl;
031import org.kuali.rice.krms.impl.repository.KrmsTypeBoServiceImpl;
032import org.kuali.rice.krms.impl.repository.TermBoService;
033import org.kuali.rice.krms.impl.repository.TermBoServiceImpl;
034import org.kuali.rice.test.BaselineTestCase.BaselineMode;
035import org.kuali.rice.test.BaselineTestCase.Mode;
036
037import java.util.Arrays;
038import java.util.Collections;
039import java.util.List;
040
041import static org.junit.Assert.assertFalse;
042import static org.junit.Assert.assertTrue;
043
044@BaselineMode(Mode.CLEAR_DB)
045public class TermRelatedBoTest extends AbstractBoTest {
046
047    private TermBoService termBoService;
048    private ContextBoService contextRepository;
049    private KrmsTypeBoService krmsTypeBoService;
050
051    @Before
052    public void setup() {
053
054        // wire up BO services
055
056        termBoService = new TermBoServiceImpl();
057
058        // TODO: fix
059        ((TermBoServiceImpl)termBoService).setDataObjectService(GlobalResourceLoader.<DataObjectService>getService(
060                "dataObjectService"));
061
062        contextRepository = new ContextBoServiceImpl();
063        ((ContextBoServiceImpl)contextRepository).setDataObjectService(getDataObjectService());
064
065        krmsTypeBoService = new KrmsTypeBoServiceImpl();
066        ((KrmsTypeBoServiceImpl)krmsTypeBoService).setDataObjectService(getDataObjectService());
067    }
068
069    @Test
070    public void creationTest() {
071
072        // create prerequisite objects
073        ContextDefinition contextDefinition = createContext();
074        KrmsTypeDefinition krmsTermResolverTypeDefinition = createTermResolverType();
075
076        // output TermSpec
077        TermSpecificationDefinition outputTermSpec =
078                TermSpecificationDefinition.Builder.create(null, "outputTermSpec", contextDefinition.getId(),
079                        "java.lang.String").build();
080        outputTermSpec = termBoService.createTermSpecification(outputTermSpec);
081
082        // prereq TermSpec
083        TermSpecificationDefinition prereqTermSpec =
084                TermSpecificationDefinition.Builder.create(null, "prereqTermSpec", contextDefinition.getId(),
085                        "java.lang.String").build();
086        prereqTermSpec = termBoService.createTermSpecification(prereqTermSpec);
087
088        // TermResolver
089        TermResolverDefinition termResolverDef =
090                TermResolverDefinition.Builder.create(null, "KRMS", "testResolver", krmsTermResolverTypeDefinition.getId(),
091                        TermSpecificationDefinition.Builder.create(outputTermSpec),
092                        Collections.singleton(TermSpecificationDefinition.Builder.create(prereqTermSpec)),
093                        null,
094                        Collections.singleton("testParamName")).build();
095        termResolverDef = termBoService.createTermResolver(termResolverDef);
096
097        // Term Param
098        TermParameterDefinition.Builder termParamBuilder =
099                TermParameterDefinition.Builder.create(null, null, "testParamName", "testParamValue");
100
101        // Term
102        TermDefinition termDefinition =
103                TermDefinition.Builder.create(null, TermSpecificationDefinition.Builder.create(outputTermSpec), Collections.singletonList(termParamBuilder)).build();
104        termBoService.createTerm(termDefinition);
105    }
106
107    /**
108     * Verify that Terms can be updated (including modification of an existing TermParameter) by the TermBoServiceImpl
109     */
110    @Test
111    public void updateTermChangeParameterTest() {
112        TermDefinition termDefinition = createTermForUpdate();
113
114        // Change some things so that we can verify the updates occurred
115        TermDefinition.Builder updateTermBuilder = TermDefinition.Builder.create(termDefinition);
116        updateTermBuilder.setDescription("updated description");
117        assertTrue(updateTermBuilder.getParameters().size() == 1);
118        updateTermBuilder.getParameters().get(0).setValue("updatedParamValue");
119
120        termBoService.updateTerm(updateTermBuilder.build());
121
122        // check that the update stuck
123        TermDefinition updatedTerm = termBoService.getTerm(termDefinition.getId());
124
125        assertFalse("descriptions should not be equal after update",
126                updatedTerm.getDescription().equals(termDefinition.getDescription()));
127
128        assertTrue(updatedTerm.getParameters().size() == 1);
129
130        TermParameterDefinition updatedParam = updatedTerm.getParameters().get(0);
131        assertTrue(updatedParam.getValue().equals("updatedParamValue"));
132    }
133
134    /**
135     * Verify that Terms can be updated (including replacement of a TermParameter) by the TermBoServiceImpl
136     */
137    @Test
138    public void updateTermReplaceParameterTest() {
139        TermDefinition termDefinition = createTermForUpdate();
140
141        // Change some things so that we can verify the updates occurred
142        TermDefinition.Builder updateTermBuilder = TermDefinition.Builder.create(termDefinition);
143        updateTermBuilder.setDescription("updated description");
144        assertTrue(updateTermBuilder.getParameters().size() == 1);
145        updateTermBuilder.getParameters().clear();
146        updateTermBuilder.getParameters().add(TermParameterDefinition.Builder.create(null, termDefinition.getId(), "secondParamName", "secondParamValue"));
147
148        termBoService.updateTerm(updateTermBuilder.build());
149
150        // check that the update stuck
151        TermDefinition updatedTerm = termBoService.getTerm(termDefinition.getId());
152
153        assertFalse("descriptions should not be equal after update",
154                updatedTerm.getDescription().equals(termDefinition.getDescription()));
155
156        assertTrue(updatedTerm.getParameters().size() == 1);
157
158        TermParameterDefinition secondParam = updatedTerm.getParameters().get(0);
159        assertTrue(secondParam.getValue().equals("secondParamValue"));
160    }
161
162    private ContextDefinition createContext() {
163
164        // KrmsType for context
165        KrmsTypeDefinition krmsContextTypeDefinition = KrmsTypeDefinition.Builder.create("KrmsTestContextType", "KRMS").build();
166        krmsContextTypeDefinition = krmsTypeBoService.createKrmsType(krmsContextTypeDefinition);
167
168        // Context
169        ContextDefinition.Builder contextBuilder = ContextDefinition.Builder.create("KRMS", "testContext");
170        contextBuilder.setTypeId(krmsContextTypeDefinition.getId());
171        ContextDefinition contextDefinition = contextBuilder.build();
172        contextDefinition = contextRepository.createContext(contextDefinition);
173
174        return contextDefinition;
175    }
176
177    private TermDefinition createTermForUpdate() {
178        ContextDefinition contextDefinition = createContext();
179
180        // TermSpec -- we need one to create a term
181        TermSpecificationDefinition termSpec =
182                TermSpecificationDefinition.Builder.create(null, "TermUpdateTestTermSpec", contextDefinition.getId(),
183                        "java.lang.String").build();
184        termSpec = termBoService.createTermSpecification(termSpec);
185
186        // Term -- create the term that we'll update
187        List<TermParameterDefinition.Builder> paramBuilders =
188                Arrays.asList(TermParameterDefinition.Builder.create(null, null, "paramName", "paramValue"));
189        TermDefinition termDefinition =
190                TermDefinition.Builder.create(null, TermSpecificationDefinition.Builder.create(termSpec), paramBuilders).build();
191        termDefinition = termBoService.createTerm(termDefinition);
192        return termDefinition;
193    }
194
195    private KrmsTypeDefinition createTermResolverType() {
196        // KrmsType for TermResolver
197        KrmsTypeDefinition krmsTermResolverTypeDefinition = KrmsTypeDefinition.Builder.create("KrmsTestResolverType", "KRMS").build();
198        krmsTermResolverTypeDefinition = krmsTypeBoService.createKrmsType(krmsTermResolverTypeDefinition);
199
200        return krmsTermResolverTypeDefinition;
201    }
202}