Coverage Report

Coverage Report - org.kuali.student.common.test.spring.LoadDataBean

Classes in this File

Line Coverage

Branch Coverage

Complexity

LoadDataBean

84%

48/57

81%

26/32

5.6

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community 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.osedu.org/licenses/ECL-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.
  */
 
 package org.kuali.student.common.test.spring;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.util.List;
 import java.util.Map;
 
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import javax.persistence.PersistenceException;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.support.FileSystemXmlApplicationContext;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.transaction.annotation.Transactional;
 
 @Transactional
 public class LoadDataBean implements ApplicationContextAware{
         private static final Log LOG = LogFactory.getLog(LoadDataBean.class);
 
 
 
         @PersistenceContext
         EntityManager em;
         private boolean loaded = false;
         private String daoAnnotations;
 
         private ApplicationContext applicationContext;
 
         public void loadData(){
                 if (daoAnnotations == null || loaded || daoAnnotations.trim().isEmpty()) {
                         return;
                 }
 
                 // Load all the beans
                 String[] classes = daoAnnotations.split(",");
                 for (String line : classes) {
                         try {
                                 String[] split = line.split("\\|");
 
                                 // Invoke the data loader for this dao
                 invokeDataLoader(split[0]);
 
                 // Load data bean file for this dao
                 if (split.length > 1&& !split[1].isEmpty()) {
                                     String testDataFile = split[1];
 
                                         ApplicationContext ac = new FileSystemXmlApplicationContext(
                                                         testDataFile);
                                         for (Object bean : (List<?>) ac.getBean("persistList")) {
                                                 if(!em.contains(bean)){
                                                         em.persist(bean);
                                                 }
                                         }
                                 }
                 // Load sql file for this dao
                 if (split.length > 2&& !split[2].isEmpty()) {
 
                                         String testDataFile = split[2];
                                     File sqlFile;
                                     if(testDataFile.startsWith("classpath:")){
                                             sqlFile = new ClassPathResource(testDataFile.substring("classpath:".length())).getFile();
                                     }else{
                                             sqlFile = new File(testDataFile);
                                     }
                                         BufferedReader in
                                            = new BufferedReader(new FileReader(sqlFile));
                                         try {
                                             String ln = "";
                                             int lnNr = 0;
 
                                             try {
                             while((ln=in.readLine())!=null){
                                 lnNr++;
                                     if(!ln.startsWith("/")&&!ln.startsWith("--")&&StringUtils.isNotBlank(ln)){
                                             ln=ln.replaceFirst("[;/]\\s*$","");
                                             em.createNativeQuery(ln).executeUpdate();
                                     }
                             }
                         } catch (PersistenceException e) {
                             LOG.error("Failed statement at line " + lnNr + ": " + ln);
                             throw e;
                         }
                                         } finally {
                                             in.close();
                                         }
                                 }
 
                         } catch (Exception e) {
                                 throw new RuntimeException(e);
                         }
                 }
 
                 loaded = true;
 
         }
 
         protected void invokeDataLoader(String dao){
             try {
             //Check if there is a loader class for this dao
                 Class<?> daoType = Class.forName(dao).getInterfaces()[0];
 
                 Class<?> clazz = Class.forName(daoType.getName() + "Loader");
             DaoLoader daoLoader = (DaoLoader)clazz.newInstance();
 
             //Get spring bean for the dao
             Map<?,?> daoBeans = applicationContext.getBeansOfType(daoType);
 
             //Invoke the loader for this doa bean (there shouldn't be more than one)
             if (daoBeans.size() == 1){
                 daoLoader.setDao(daoBeans.values().iterator().next());
                 daoLoader.run();
             }
 
             } catch (ClassNotFoundException cnfe) {
                     LOG.info(cnfe);
             } catch (Exception e) {
             LOG.error(e);
         }
         }
 
         /**
          * @return the daoAnnotations
          */
         public String getDaoAnnotations() {
                 return daoAnnotations;
         }
 
         /**
          * @param daoAnnotations
          *            the daoAnnotations to set
          */
         public void setDaoAnnotations(String daoAnnotations) {
                 this.daoAnnotations = daoAnnotations;
         }
 
         public void setApplicationContext(ApplicationContext applicationContext){
             this.applicationContext = applicationContext;
         }
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.test.spring;
17
18		import java.io.BufferedReader;
19		import java.io.File;
20		import java.io.FileReader;
21		import java.util.List;
22		import java.util.Map;
23
24		import javax.persistence.EntityManager;
25		import javax.persistence.PersistenceContext;
26		import javax.persistence.PersistenceException;
27
28		import org.apache.commons.lang.StringUtils;
29		import org.apache.commons.logging.Log;
30		import org.apache.commons.logging.LogFactory;
31		import org.springframework.context.ApplicationContext;
32		import org.springframework.context.ApplicationContextAware;
33		import org.springframework.context.support.FileSystemXmlApplicationContext;
34		import org.springframework.core.io.ClassPathResource;
35		import org.springframework.transaction.annotation.Transactional;
36
37		@Transactional
38	5	public class LoadDataBean implements ApplicationContextAware{
39	1	private static final Log LOG = LogFactory.getLog(LoadDataBean.class);
40
41
42
43		@PersistenceContext
44		EntityManager em;
45	5	private boolean loaded = false;
46		private String daoAnnotations;
47
48		private ApplicationContext applicationContext;
49
50		public void loadData(){
51	6	if (daoAnnotations == null \|\| loaded \|\| daoAnnotations.trim().isEmpty()) {
52	4	return;
53		}
54
55		// Load all the beans
56	2	String[] classes = daoAnnotations.split(",");
57	6	for (String line : classes) {
58		try {
59	4	String[] split = line.split("\\\|");
60
61		// Invoke the data loader for this dao
62	4	invokeDataLoader(split[0]);
63
64		// Load data bean file for this dao
65	4	if (split.length > 1&& !split[1].isEmpty()) {
66	2	String testDataFile = split[1];
67
68	2	ApplicationContext ac = new FileSystemXmlApplicationContext(
69		testDataFile);
70	2	for (Object bean : (List<?>) ac.getBean("persistList")) {
71	4	if(!em.contains(bean)){
72	4	em.persist(bean);
73		}
74		}
75		}
76		// Load sql file for this dao
77	4	if (split.length > 2&& !split[2].isEmpty()) {
78
79	1	String testDataFile = split[2];
80		File sqlFile;
81	1	if(testDataFile.startsWith("classpath:")){
82	1	sqlFile = new ClassPathResource(testDataFile.substring("classpath:".length())).getFile();
83		}else{
84	0	sqlFile = new File(testDataFile);
85		}
86	1	BufferedReader in
87		= new BufferedReader(new FileReader(sqlFile));
88		try {
89	1	String ln = "";
90	1	int lnNr = 0;
91
92		try {
93	22	while((ln=in.readLine())!=null){
94	21	lnNr++;
95	21	if(!ln.startsWith("/")&&!ln.startsWith("--")&&StringUtils.isNotBlank(ln)){
96	2	ln=ln.replaceFirst("[;/]\\s*$","");
97	2	em.createNativeQuery(ln).executeUpdate();
98		}
99		}
100	0	} catch (PersistenceException e) {
101	0	LOG.error("Failed statement at line " + lnNr + ": " + ln);
102	0	throw e;
103	1	}
104		} finally {
105	1	in.close();
106	1	}
107		}
108
109	0	} catch (Exception e) {
110	0	throw new RuntimeException(e);
111	4	}
112		}
113
114	2	loaded = true;
115
116	2	}
117
118		protected void invokeDataLoader(String dao){
119		try {
120		//Check if there is a loader class for this dao
121	4	Class<?> daoType = Class.forName(dao).getInterfaces()[0];
122
123	4	Class<?> clazz = Class.forName(daoType.getName() + "Loader");
124	2	DaoLoader daoLoader = (DaoLoader)clazz.newInstance();
125
126		//Get spring bean for the dao
127	2	Map<?,?> daoBeans = applicationContext.getBeansOfType(daoType);
128
129		//Invoke the loader for this doa bean (there shouldn't be more than one)
130	2	if (daoBeans.size() == 1){
131	2	daoLoader.setDao(daoBeans.values().iterator().next());
132	2	daoLoader.run();
133		}
134
135	2	} catch (ClassNotFoundException cnfe) {
136	2	LOG.info(cnfe);
137	0	} catch (Exception e) {
138	0	LOG.error(e);
139	4	}
140	4	}
141
142		/**
143		* @return the daoAnnotations
144		*/
145		public String getDaoAnnotations() {
146	0	return daoAnnotations;
147		}
148
149		/**
150		* @param daoAnnotations
151		* the daoAnnotations to set
152		*/
153		public void setDaoAnnotations(String daoAnnotations) {
154	3	this.daoAnnotations = daoAnnotations;
155	3	}
156
157		public void setApplicationContext(ApplicationContext applicationContext){
158	3	this.applicationContext = applicationContext;
159	3	}
160		}