View Javadoc
1   /**
2    * Copyright 2014 Internet2
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *   http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  /**
17   * 
18   */
19  package edu.internet2.middleware.grouper.tableIndex;
20  
21  import java.util.HashSet;
22  import java.util.Random;
23  import java.util.Set;
24  
25  import junit.textui.TestRunner;
26  import edu.internet2.middleware.grouper.Group;
27  import edu.internet2.middleware.grouper.GroupSave;
28  import edu.internet2.middleware.grouper.GrouperSession;
29  import edu.internet2.middleware.grouper.Stem;
30  import edu.internet2.middleware.grouper.StemFinder;
31  import edu.internet2.middleware.grouper.StemSave;
32  import edu.internet2.middleware.grouper.attr.AttributeDef;
33  import edu.internet2.middleware.grouper.attr.AttributeDefName;
34  import edu.internet2.middleware.grouper.attr.AttributeDefNameSave;
35  import edu.internet2.middleware.grouper.attr.AttributeDefSave;
36  import edu.internet2.middleware.grouper.attr.AttributeDefTest;
37  import edu.internet2.middleware.grouper.cfg.GrouperConfig;
38  import edu.internet2.middleware.grouper.helper.GrouperTest;
39  import edu.internet2.middleware.grouper.helper.SubjectTestHelper;
40  import edu.internet2.middleware.grouper.internal.dao.hib3.Hib3TableIndexDAO;
41  import edu.internet2.middleware.grouper.internal.util.GrouperUuid;
42  import edu.internet2.middleware.grouper.misc.GrouperDAOFactory;
43  import edu.internet2.middleware.grouper.privs.AttributeDefPrivilege;
44  import edu.internet2.middleware.grouper.privs.NamingPrivilege;
45  import edu.internet2.middleware.grouper.util.GrouperUtil;
46  
47  
48  /**
49   * @author mchyzer
50   *
51   */
52  public class TableIndexTest extends GrouperTest {
53  
54    /**
55     * 
56     */
57    @Override
58    protected void setUp() {
59      super.setUp();
60      
61      GrouperConfig.retrieveConfig().propertiesOverrideMap().put("grouper.tableIndex.groupWhoCanAssignIdIndex", "etc:canAssignIdIndex");
62  
63      GrouperSession grouperSession = GrouperSession.startRootSession();
64      Group group = new GroupSave(grouperSession).assignName("etc:canAssignIdIndex").assignCreateParentStemsIfNotExist(true).save();
65      
66      group.addMember(SubjectTestHelper.SUBJ0);
67      
68    }
69  
70    /**
71     * 
72     * @param args
73     */
74    public static void main(String[] args) {
75      TestRunner.run(new TableIndexTest("testSaveAttributeDefName"));
76    }
77  
78    /**
79     * 
80     */
81    public TableIndexTest() {
82      super();
83    }
84  
85    /**
86     * 
87     * @param name
88     */
89    public TableIndexTest(String name) {
90      super(name);
91    }
92  
93    public void testSaveGroup() {
94      GrouperSession grouperSession = GrouperSession.startRootSession();
95      for (int i=0;i<92;i++) {
96        Group group = new GroupSave(grouperSession).assignName("test:someName" 
97            + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
98            .assignCreateParentStemsIfNotExist(true).save();
99        Long idIndex = group.getIdIndex();
100       assertNotNull(idIndex);
101     }
102     
103     Stem stem = StemFinder.findByName(grouperSession, "test", true);
104     stem.grantPriv(SubjectTestHelper.SUBJ0, NamingPrivilege.CREATE);
105     stem.grantPriv(SubjectTestHelper.SUBJ1, NamingPrivilege.CREATE);
106     
107     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ0);
108     
109     Group group = new GroupSave(grouperSession).assignName("test:someName" 
110         + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
111         .assignCreateParentStemsIfNotExist(true).save();
112     Long idIndex = group.getIdIndex();
113     assertNotNull(idIndex);
114     
115     
116     GrouperSession.stopQuietly(grouperSession);
117     
118     
119     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ1);
120     
121     try {
122       group = new GroupSave(grouperSession).assignName("test:someName" 
123           + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
124           .assignCreateParentStemsIfNotExist(true).save();
125       fail("Shouldnt get here");
126     } catch (RuntimeException e) {
127       //good
128     }
129     
130     GrouperSession.stopQuietly(grouperSession);
131     
132     
133   }
134   
135   /**
136    * 
137    */
138   public void testHibernate() {
139     
140     TableIndex tableIndex = GrouperDAOFactory.getFactory().getTableIndex().findByType(TableIndexType.group);
141     
142     if (tableIndex != null) {
143       GrouperDAOFactory.getFactory().getTableIndex().delete(tableIndex);
144     }
145     
146     tableIndex = new TableIndex();
147     tableIndex.setType(TableIndexType.group);
148     tableIndex.setId(GrouperUuid.getUuid());
149     tableIndex.setLastIndexReserved(10);
150     tableIndex.saveOrUpdate();
151   }
152   
153 
154   /**
155    * 
156    */
157   public void testIndexesGroup() {
158     GrouperSession grouperSession = GrouperSession.startRootSession();
159     long originalNumberOfTimesIndexesReserved = Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes;
160     Set<Long> idIndexes = new HashSet<Long>();
161     for (int i=0;i<92;i++) {
162       Group group = new GroupSave(grouperSession).assignName("test:someName" + GrouperUtil.uniqueId()).assignCreateParentStemsIfNotExist(true).save();
163       Long idIndex = group.getIdIndex();
164       assertNotNull(idIndex);
165       assertFalse(idIndexes.contains(idIndex));
166       idIndexes.add(idIndex);
167     }
168     assertTrue(9 <= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
169     assertTrue(11 >= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
170   }
171 
172   /**
173    * 
174    */
175   public void testIndexesStem() {
176     GrouperSession grouperSession = GrouperSession.startRootSession();
177     long originalNumberOfTimesIndexesReserved = Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes;
178     Set<Long> idIndexes = new HashSet<Long>();
179     for (int i=0;i<92;i++) {
180       Stem stem = new StemSave(grouperSession).assignName("test:someName" + GrouperUtil.uniqueId()).assignCreateParentStemsIfNotExist(true).save();
181       Long idIndex = stem.getIdIndex();
182       assertNotNull(idIndex);
183       assertFalse(idIndexes.contains(idIndex));
184       idIndexes.add(idIndex);
185     }
186     assertTrue(9 <= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
187     assertTrue(11 >= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
188   }
189 
190   /**
191    * 
192    */
193   public void testIndexesAttributeDef() {
194     GrouperSession grouperSession = GrouperSession.startRootSession();
195     long originalNumberOfTimesIndexesReserved = Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes;
196     Set<Long> idIndexes = new HashSet<Long>();
197     for (int i=0;i<92;i++) {
198       AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("test:someName" + GrouperUtil.uniqueId()).assignCreateParentStemsIfNotExist(true).save();
199       Long idIndex = attributeDef.getIdIndex();
200       assertNotNull(idIndex);
201       assertFalse(idIndexes.contains(idIndex));
202       idIndexes.add(idIndex);
203     }
204     assertTrue(9 <= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
205     assertTrue(11 >= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
206   }
207 
208   /**
209    * 
210    */
211   public void testIndexesAttributeDefName() {
212     GrouperSession grouperSession = GrouperSession.startRootSession();
213     long originalNumberOfTimesIndexesReserved = Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes;
214     Set<Long> idIndexes = new HashSet<Long>();
215     AttributeDef attributeDef = AttributeDefTest.exampleAttributeDefDb();
216     attributeDef.store();
217     for (int i=0;i<92;i++) {
218       AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("test:someName" + GrouperUtil.uniqueId()).assignCreateParentStemsIfNotExist(true).save();
219       Long idIndex = attributeDefName.getIdIndex();
220       assertNotNull(idIndex);
221       assertFalse(idIndexes.contains(idIndex));
222       idIndexes.add(idIndex);
223     }
224     assertTrue(9 <= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
225     assertTrue(11 >= Hib3TableIndexDAO.testingNumberOfTimesReservedIndexes - originalNumberOfTimesIndexesReserved);
226   }
227 
228   /**
229    * 
230    */
231   public void testSaveStem() {
232     GrouperSession grouperSession = GrouperSession.startRootSession();
233     for (int i=0;i<92;i++) {
234       Stem folder = new StemSave(grouperSession).assignName("test:someName" 
235           + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
236           .assignCreateParentStemsIfNotExist(true).save();
237       Long idIndex = folder.getIdIndex();
238       assertNotNull(idIndex);
239     }
240     
241     Stem stem = StemFinder.findByName(grouperSession, "test", true);
242     stem.grantPriv(SubjectTestHelper.SUBJ0, NamingPrivilege.STEM);
243     stem.grantPriv(SubjectTestHelper.SUBJ1, NamingPrivilege.STEM);
244     
245     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ0);
246     
247     Stem folder = new StemSave(grouperSession).assignName("test:someName" 
248         + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
249         .assignCreateParentStemsIfNotExist(true).save();
250     Long idIndex = folder.getIdIndex();
251     assertNotNull(idIndex);
252     
253     
254     GrouperSession.stopQuietly(grouperSession);
255     
256     
257     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ1);
258     
259     try {
260       folder = new StemSave(grouperSession).assignName("test:someName" 
261           + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
262           .assignCreateParentStemsIfNotExist(true).save();
263       fail("Shouldnt get here");
264     } catch (RuntimeException e) {
265       //good
266     }
267     
268     GrouperSession.stopQuietly(grouperSession);
269     
270 
271   }
272   
273   /**
274    * 
275    */
276   public void testSaveAttributeDef() {
277     GrouperSession grouperSession = GrouperSession.startRootSession();
278     for (int i=0;i<92;i++) {
279       AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("test:someName" 
280           + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
281           .assignCreateParentStemsIfNotExist(true).save();
282       Long idIndex = attributeDef.getIdIndex();
283       assertNotNull(idIndex);
284     }
285     Stem stem = StemFinder.findByName(grouperSession, "test", true);
286     stem.grantPriv(SubjectTestHelper.SUBJ0, NamingPrivilege.CREATE);
287     stem.grantPriv(SubjectTestHelper.SUBJ1, NamingPrivilege.CREATE);
288     
289     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ0);
290     
291     AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("test:someName" 
292         + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
293         .assignCreateParentStemsIfNotExist(true).save();
294     Long idIndex = attributeDef.getIdIndex();
295     assertNotNull(idIndex);
296     
297     GrouperSession.stopQuietly(grouperSession);
298     
299     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ1);
300     
301     try {
302       attributeDef = new AttributeDefSave(grouperSession).assignName("test:someName" 
303           + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
304           .assignCreateParentStemsIfNotExist(true).save();
305       fail("Shouldnt get here");
306     } catch (RuntimeException e) {
307       //good
308     }
309     
310     GrouperSession.stopQuietly(grouperSession);
311   }
312 
313   /**
314    * 
315    */
316   public void testSaveAttributeDefName() {
317     GrouperSession grouperSession = GrouperSession.startRootSession();
318     AttributeDef attributeDef = AttributeDefTest.exampleAttributeDefDb();
319     for (int i=0;i<92;i++) {
320       AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("test:someName" 
321           + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
322           .assignCreateParentStemsIfNotExist(true).save();
323       Long idIndex = attributeDefName.getIdIndex();
324       assertNotNull(idIndex);
325     }
326     
327     Stem stem = StemFinder.findByName(grouperSession, "test", true);
328     stem.grantPriv(SubjectTestHelper.SUBJ0, NamingPrivilege.CREATE);
329     stem.grantPriv(SubjectTestHelper.SUBJ1, NamingPrivilege.CREATE);
330     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_ADMIN, false);
331     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ1, AttributeDefPrivilege.ATTR_ADMIN, false);
332     
333     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ0);
334     
335     AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("test:someName" 
336         + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
337         .assignCreateParentStemsIfNotExist(true).save();
338     Long idIndex = attributeDefName.getIdIndex();
339     assertNotNull(idIndex);
340     
341     GrouperSession.stopQuietly(grouperSession);
342     
343     grouperSession = GrouperSession.start(SubjectTestHelper.SUBJ1);
344     
345     try {
346       attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("test:someName" 
347           + GrouperUtil.uniqueId()).assignIdIndex((long)new Random().nextInt(100000) + 10000)
348           .assignCreateParentStemsIfNotExist(true).save();
349       fail("Shouldnt get here");
350     } catch (RuntimeException e) {
351       //good
352     }
353     
354     GrouperSession.stopQuietly(grouperSession);
355 
356   }
357   
358 
359 }