001    /*
002     *   Copyright (C) Christian Schulte, 2005-206
003     *   All rights reserved.
004     *
005     *   Redistribution and use in source and binary forms, with or without
006     *   modification, are permitted provided that the following conditions
007     *   are met:
008     *
009     *     o Redistributions of source code must retain the above copyright
010     *       notice, this list of conditions and the following disclaimer.
011     *
012     *     o Redistributions in binary form must reproduce the above copyright
013     *       notice, this list of conditions and the following disclaimer in
014     *       the documentation and/or other materials provided with the
015     *       distribution.
016     *
017     *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
018     *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
019     *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
020     *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
021     *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
022     *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
023     *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
024     *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
025     *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
026     *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
027     *
028     *   $JOMC: ModulesTest.java 4200 2012-01-25 09:46:13Z schulte2005 $
029     *
030     */
031    package org.jomc.model.test;
032    
033    import java.util.logging.Level;
034    import javax.xml.bind.JAXBContext;
035    import javax.xml.bind.JAXBElement;
036    import javax.xml.bind.JAXBException;
037    import javax.xml.bind.util.JAXBSource;
038    import org.jomc.model.Dependencies;
039    import org.jomc.model.Dependency;
040    import org.jomc.model.Implementation;
041    import org.jomc.model.Implementations;
042    import org.jomc.model.Instance;
043    import org.jomc.model.Message;
044    import org.jomc.model.Messages;
045    import org.jomc.model.ModelObject;
046    import org.jomc.model.Modules;
047    import org.jomc.model.Properties;
048    import org.jomc.model.Property;
049    import org.jomc.model.Specification;
050    import org.jomc.model.SpecificationReference;
051    import org.jomc.model.Specifications;
052    import org.jomc.model.Text;
053    import org.jomc.model.Texts;
054    import org.jomc.model.modlet.ModelHelper;
055    import org.jomc.modlet.Model;
056    import org.jomc.modlet.ModelContext;
057    import org.jomc.modlet.ModelContextFactory;
058    import org.jomc.modlet.ModelException;
059    import org.jomc.modlet.ModelValidationReport;
060    import org.junit.Assert;
061    
062    /**
063     * Test cases for class {@code org.jomc.model.Modules}.
064     *
065     * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a> 1.0
066     * @version $JOMC: ModulesTest.java 4200 2012-01-25 09:46:13Z schulte2005 $
067     */
068    public class ModulesTest
069    {
070    
071        /** Constant to prefix relative resource names with. */
072        private static final String ABSOLUTE_RESOURCE_NAME_PREFIX = "/org/jomc/model/test/";
073    
074        /** The {@code TestSuite} holding the module tests to run. */
075        private TestSuite testSuite;
076    
077        /** The {@code ModelContext} instance tests are performed with. */
078        private ModelContext modelContext;
079    
080        /** Creates a new {@code ModulesTest} instance. */
081        public ModulesTest()
082        {
083            super();
084        }
085    
086        /**
087         * Gets the {@code TestSuite} holding the module tests to run.
088         *
089         * @return The {@code TestSuite} holding the module tests to run.
090         *
091         * @see #newTestSuite()
092         */
093        public TestSuite getTestSuite()
094        {
095            if ( this.testSuite == null )
096            {
097                this.testSuite = this.newTestSuite();
098            }
099    
100            return this.testSuite;
101        }
102    
103        /**
104         * Creates a new {@code TestSuite} holding module tests to run.
105         *
106         * @return A new {@code TestSuite} holding module tests to run.
107         *
108         * @see #getTestSuite()
109         */
110        protected TestSuite newTestSuite()
111        {
112            try
113            {
114                return ( (JAXBElement<TestSuite>) this.getModelContext().createUnmarshaller(
115                    ModelObject.MODEL_PUBLIC_ID ).unmarshal( this.getClass().getResource(
116                    ABSOLUTE_RESOURCE_NAME_PREFIX + "ModulesTestSuite.xml" ) ) ).getValue();
117    
118            }
119            catch ( final JAXBException e )
120            {
121                throw new AssertionError( e );
122            }
123            catch ( final ModelException e )
124            {
125                throw new AssertionError( e );
126            }
127        }
128    
129        /**
130         * Gets the {@code ModelContext} instance tests are performed with.
131         *
132         * @return The {@code ModelContext} instance tests are performed with.
133         *
134         * @see #newModelContext()
135         */
136        public ModelContext getModelContext()
137        {
138            if ( this.modelContext == null )
139            {
140                this.modelContext = this.newModelContext();
141                this.modelContext.getListeners().add( new ModelContext.Listener()
142                {
143    
144                    @Override
145                    public void onLog( final Level level, String message, Throwable t )
146                    {
147                        super.onLog( level, message, t );
148                        System.out.println( "[" + level.getLocalizedName() + "] " + message );
149                        if ( t != null )
150                        {
151                            t.printStackTrace( System.out );
152                        }
153                    }
154    
155                } );
156            }
157    
158            return this.modelContext;
159        }
160    
161        /**
162         * Creates a new {@code ModelContext} instance tests are performed with.
163         *
164         * @return A new {@code ModelContext} instance tests are performed with.
165         *
166         * @see #getModelContext()
167         */
168        protected ModelContext newModelContext()
169        {
170            return ModelContextFactory.newInstance().newModelContext();
171        }
172    
173        /**
174         * Runs a {@code ImplementationTestType} test.
175         *
176         * @param identifier The identifier of the {@code ImplementationTestType} to run.
177         *
178         * @throws Exception if running the test fails.
179         */
180        public final void testImplementation( final String identifier ) throws Exception
181        {
182            Assert.assertNotNull( "identifier", identifier );
183    
184            ImplementationTestType test = null;
185    
186            for ( ImplementationTestType candidate : this.getTestSuite().getImplementationTest() )
187            {
188                if ( identifier.equals( candidate.getIdentifier() ) )
189                {
190                    test = candidate;
191                    break;
192                }
193            }
194    
195            Assert.assertNotNull( "Implementation test '" + identifier + "' not found.", test );
196    
197            final JAXBContext jaxbContext = this.getModelContext().createContext( ModelObject.MODEL_PUBLIC_ID );
198    
199            System.out.println( "ImplementationTest: " + test.getIdentifier() );
200    
201            final JAXBElement<Modules> modules = (JAXBElement<Modules>) test.getModules().getAny();
202            final Model model = new Model();
203            model.setIdentifier( ModelObject.MODEL_PUBLIC_ID );
204            ModelHelper.setModules( model, modules.getValue() );
205    
206            final ModelValidationReport modulesReport = this.getModelContext().validateModel( model );
207    
208            if ( !modulesReport.isModelValid() )
209            {
210                log( modulesReport );
211            }
212    
213            Assert.assertTrue( "[" + test.getIdentifier() + "] Unexpected invalid modules.",
214                               modulesReport.isModelValid() );
215    
216            final JAXBElement<Implementation> expected =
217                (JAXBElement<Implementation>) test.getImplementation().getAny();
218    
219            final ModelValidationReport implementationReport = this.getModelContext().validateModel(
220                ModelObject.MODEL_PUBLIC_ID, new JAXBSource( jaxbContext, expected ) );
221    
222            if ( !implementationReport.isModelValid() )
223            {
224                log( implementationReport );
225            }
226    
227            Assert.assertTrue( "[" + test.getIdentifier() + "] Unexpected invalid implementation.",
228                               implementationReport.isModelValid() );
229    
230            final Implementation i = modules.getValue().getImplementation( expected.getValue().getIdentifier() );
231    
232            Assert.assertNotNull( i );
233            assertEquals( expected.getValue(), i );
234            assertEquals( expected.getValue().getDependencies(),
235                          modules.getValue().getDependencies( expected.getValue().getIdentifier() ) );
236    
237            assertEquals( expected.getValue().getMessages(),
238                          modules.getValue().getMessages( expected.getValue().getIdentifier() ) );
239    
240            assertEquals( expected.getValue().getProperties(),
241                          modules.getValue().getProperties( expected.getValue().getIdentifier() ) );
242    
243            assertEquals( expected.getValue().getSpecifications(),
244                          modules.getValue().getSpecifications( expected.getValue().getIdentifier() ) );
245    
246        }
247    
248        /**
249         * Runs a {@code InstanceTestType} test.
250         *
251         * @param identifier The identifier of the {@code InstanceTestType} to run.
252         *
253         * @throws Exception if running the test fails.
254         */
255        public final void testInstance( final String identifier ) throws Exception
256        {
257            Assert.assertNotNull( "identifier", identifier );
258    
259            InstanceTestType test = null;
260    
261            for ( InstanceTestType candidate : this.getTestSuite().getInstanceTest() )
262            {
263                if ( identifier.equals( candidate.getIdentifier() ) )
264                {
265                    test = candidate;
266                    break;
267                }
268            }
269    
270            Assert.assertNotNull( "Instance test '" + identifier + "' not found.", test );
271    
272            System.out.println( "InstanceTest: " + test.getIdentifier() );
273    
274            final JAXBElement<Modules> modules = (JAXBElement<Modules>) test.getModules().getAny();
275            final Model model = new Model();
276            model.setIdentifier( ModelObject.MODEL_PUBLIC_ID );
277            ModelHelper.setModules( model, modules.getValue() );
278    
279            ModelValidationReport validationReport = this.getModelContext().validateModel( model );
280    
281            if ( !validationReport.isModelValid() )
282            {
283                log( validationReport );
284            }
285    
286            Assert.assertTrue( "[" + test.getIdentifier() + "] Unexpected invalid modules.",
287                               validationReport.isModelValid() );
288    
289            final JAXBElement<Instance> expected = (JAXBElement<Instance>) test.getInstance().getAny();
290            validationReport = this.getModelContext().validateModel(
291                ModelObject.MODEL_PUBLIC_ID,
292                new JAXBSource( this.getModelContext().createContext( ModelObject.MODEL_PUBLIC_ID ), expected ) );
293    
294            if ( !validationReport.isModelValid() )
295            {
296                log( validationReport );
297            }
298    
299            Assert.assertTrue( "[" + test.getIdentifier() + "] Unexpected invalid instance.",
300                               validationReport.isModelValid() );
301    
302            Instance instance = null;
303    
304            if ( test.getDependencyName() != null )
305            {
306                final Dependencies dependencies =
307                    modules.getValue().getDependencies( test.getImplementationIdentifier() );
308    
309                Assert.assertNotNull( "[" + test.getIdentifier() + "] No dependencies for implementation '"
310                                      + test.getImplementationIdentifier() + "' not found.", dependencies );
311    
312                final Dependency d = dependencies.getDependency( test.getDependencyName() );
313                Assert.assertNotNull( "[" + test.getIdentifier() + "] Dependency '" + test.getDependencyName()
314                                      + "' not found.", d );
315    
316                Assert.assertNotNull( "[" + test.getIdentifier() + "] Expected implementation name of dependency '"
317                                      + test.getDependencyName() + "' not set.", d.getImplementationName() );
318    
319                final Implementations implementations = modules.getValue().getImplementations( d.getIdentifier() );
320                Assert.assertNotNull( "[" + test.getIdentifier() + "] Expected implementations of dependency '"
321                                      + test.getDependencyName() + "' not found.", implementations );
322    
323                final Implementation i = implementations.getImplementationByName( d.getImplementationName() );
324                Assert.assertNotNull( "[" + test.getIdentifier() + "] Expected '" + d.getImplementationName()
325                                      + "' implementation not found.", i );
326    
327                instance = modules.getValue().getInstance( i.getIdentifier(), d );
328            }
329            else
330            {
331                instance = modules.getValue().getInstance( test.getImplementationIdentifier() );
332            }
333    
334            Assert.assertNotNull( "[" + test.getIdentifier() + "] Expected instance not found.", instance );
335            assertEquals( expected.getValue(), instance );
336        }
337    
338        public static void assertEquals( final ModelObject expected, final ModelObject computed ) throws Exception
339        {
340            if ( expected != null )
341            {
342                Assert.assertNotNull( computed );
343                Assert.assertEquals( expected.getCreateDate(), computed.getCreateDate() );
344                Assert.assertEquals( expected.getModelVersion(), computed.getModelVersion() );
345                Assert.assertEquals( expected.isDeprecated(), computed.isDeprecated() );
346            }
347            else
348            {
349                Assert.assertNull( computed );
350            }
351        }
352    
353        public static void assertEquals( final Instance expected, final Instance computed ) throws Exception
354        {
355            if ( expected != null )
356            {
357                Assert.assertNotNull( computed );
358                assertEquals( (ModelObject) expected, (ModelObject) computed );
359                Assert.assertEquals( expected.getClazz(), computed.getClazz() );
360                assertEquals( expected.getDependencies(), computed.getDependencies() );
361                Assert.assertEquals( expected.getIdentifier(), computed.getIdentifier() );
362                assertEquals( expected.getMessages(), computed.getMessages() );
363                Assert.assertEquals( expected.getName(), computed.getName() );
364                assertEquals( expected.getProperties(), computed.getProperties() );
365                assertEquals( expected.getSpecifications(), computed.getSpecifications() );
366            }
367            else
368            {
369                Assert.assertNull( computed );
370            }
371        }
372    
373        public static void assertEquals( final Implementations expected, final Implementations computed ) throws Exception
374        {
375            if ( expected != null )
376            {
377                Assert.assertNotNull( computed );
378                assertEquals( (ModelObject) expected, (ModelObject) computed );
379    
380                for ( Implementation i : expected.getImplementation() )
381                {
382                    assertEquals( i, computed.getImplementation( i.getIdentifier() ) );
383                }
384            }
385            else
386            {
387                Assert.assertNull( computed );
388            }
389        }
390    
391        public static void assertEquals( final Implementation expected, final Implementation computed ) throws Exception
392        {
393            if ( expected != null )
394            {
395                Assert.assertNotNull( computed );
396                assertEquals( (ModelObject) expected, (ModelObject) computed );
397                Assert.assertEquals( expected.getClazz(), computed.getClazz() );
398                Assert.assertEquals( expected.getIdentifier(), computed.getIdentifier() );
399                Assert.assertEquals( expected.getLocation(), computed.getLocation() );
400                Assert.assertEquals( expected.getName(), computed.getName() );
401                Assert.assertEquals( expected.getVendor(), computed.getVendor() );
402                Assert.assertEquals( expected.getVersion(), computed.getVersion() );
403                Assert.assertEquals( expected.isAbstract(), computed.isAbstract() );
404                Assert.assertEquals( expected.isFinal(), computed.isFinal() );
405                Assert.assertEquals( expected.isStateless(), computed.isStateless() );
406            }
407            else
408            {
409                Assert.assertNull( computed );
410            }
411        }
412    
413        public static void assertEquals( final Specifications expected, final Specifications computed ) throws Exception
414        {
415            if ( expected != null )
416            {
417                Assert.assertNotNull( computed );
418                assertEquals( (ModelObject) expected, (ModelObject) computed );
419    
420                for ( Specification s : expected.getSpecification() )
421                {
422                    assertEquals( s, computed.getSpecification( s.getIdentifier() ) );
423                }
424    
425                for ( SpecificationReference r : expected.getReference() )
426                {
427                    assertEquals( r, computed.getReference( r.getIdentifier() ) );
428                }
429            }
430            else
431            {
432                Assert.assertNull( computed );
433            }
434        }
435    
436        public static void assertEquals( final SpecificationReference expected, final SpecificationReference computed )
437            throws Exception
438        {
439            if ( expected != null )
440            {
441                Assert.assertNotNull( computed );
442                assertEquals( (ModelObject) expected, (ModelObject) computed );
443    
444                Assert.assertEquals( expected.getIdentifier(), computed.getIdentifier() );
445                Assert.assertEquals( expected.getVersion(), computed.getVersion() );
446                Assert.assertEquals( expected.isDeprecated(), computed.isDeprecated() );
447                Assert.assertEquals( expected.isFinal(), computed.isFinal() );
448                Assert.assertEquals( expected.isOverride(), computed.isOverride() );
449            }
450            else
451            {
452                Assert.assertNull( computed );
453            }
454        }
455    
456        public static void assertEquals( final Specification expected, final Specification computed ) throws Exception
457        {
458            if ( expected != null )
459            {
460                Assert.assertNotNull( computed );
461                assertEquals( (ModelObject) expected, (ModelObject) computed );
462    
463                Assert.assertEquals( expected.getClazz(), computed.getClazz() );
464                Assert.assertEquals( expected.getIdentifier(), computed.getIdentifier() );
465                Assert.assertEquals( expected.getMultiplicity(), computed.getMultiplicity() );
466                assertEquals( expected.getProperties(), computed.getProperties() );
467                Assert.assertEquals( expected.getScope(), computed.getScope() );
468                Assert.assertEquals( expected.getVendor(), computed.getVendor() );
469                Assert.assertEquals( expected.getVersion(), computed.getVersion() );
470            }
471            else
472            {
473                Assert.assertNull( computed );
474            }
475        }
476    
477        public static void assertEquals( final Dependencies expected, final Dependencies computed ) throws Exception
478        {
479            if ( expected != null )
480            {
481                Assert.assertNotNull( computed );
482    
483                for ( Dependency d : expected.getDependency() )
484                {
485                    assertEquals( d, computed.getDependency( d.getName() ) );
486                }
487            }
488            else
489            {
490                Assert.assertNull( computed );
491            }
492        }
493    
494        public static void assertEquals( final Dependency expected, final Dependency computed ) throws Exception
495        {
496            if ( expected != null )
497            {
498                Assert.assertNotNull( computed );
499                Assert.assertEquals( expected.getIdentifier(), computed.getIdentifier() );
500                Assert.assertEquals( expected.getImplementationName(), computed.getImplementationName() );
501                Assert.assertEquals( expected.getName(), computed.getName() );
502                Assert.assertEquals( expected.isDeprecated(), computed.isDeprecated() );
503                Assert.assertEquals( expected.isFinal(), computed.isFinal() );
504                Assert.assertEquals( expected.isOverride(), computed.isOverride() );
505                Assert.assertEquals( expected.isBound(), computed.isBound() );
506                Assert.assertEquals( expected.isOptional(), computed.isOptional() );
507                Assert.assertEquals( expected.getVersion(), computed.getVersion() );
508                assertEquals( expected.getDependencies(), computed.getDependencies() );
509                assertEquals( expected.getMessages(), computed.getMessages() );
510                assertEquals( expected.getProperties(), computed.getProperties() );
511            }
512            else
513            {
514                Assert.assertNull( computed );
515            }
516        }
517    
518        public static void assertEquals( final Messages expected, final Messages computed ) throws Exception
519        {
520            if ( expected != null )
521            {
522                Assert.assertNotNull( computed );
523    
524                for ( Message m : expected.getMessage() )
525                {
526                    assertEquals( m, computed.getMessage( m.getName() ) );
527                }
528            }
529            else
530            {
531                Assert.assertNull( computed );
532            }
533        }
534    
535        public static void assertEquals( final Message expected, final Message computed ) throws Exception
536        {
537            if ( expected != null )
538            {
539                Assert.assertNotNull( computed );
540                Assert.assertEquals( expected.getName(), computed.getName() );
541                Assert.assertEquals( expected.isDeprecated(), computed.isDeprecated() );
542                Assert.assertEquals( expected.isFinal(), computed.isFinal() );
543                Assert.assertEquals( expected.isOverride(), computed.isOverride() );
544                assertEquals( expected.getTemplate(), computed.getTemplate() );
545            }
546            else
547            {
548                Assert.assertNull( computed );
549            }
550        }
551    
552        public static void assertEquals( final Texts expected, final Texts computed ) throws Exception
553        {
554            if ( expected != null )
555            {
556                Assert.assertNotNull( computed );
557                Assert.assertEquals( expected.getDefaultLanguage(), computed.getDefaultLanguage() );
558    
559                for ( Text t : expected.getText() )
560                {
561                    Assert.assertNotNull( computed.getText( t.getLanguage() ) );
562                    Assert.assertEquals( t.getValue(), computed.getText( t.getLanguage() ).getValue() );
563                }
564    
565                for ( Text t : computed.getText() )
566                {
567                    Assert.assertNotNull( expected.getText( t.getLanguage() ) );
568                }
569            }
570            else
571            {
572                Assert.assertNull( computed );
573            }
574        }
575    
576        public static void assertEquals( final Properties expected, final Properties computed ) throws Exception
577        {
578            if ( expected != null )
579            {
580                Assert.assertNotNull( computed );
581    
582                for ( Property p : expected.getProperty() )
583                {
584                    assertEquals( p, computed.getProperty( p.getName() ) );
585                }
586            }
587            else
588            {
589                Assert.assertNull( computed );
590            }
591        }
592    
593        public static void assertEquals( final Property expected, final Property computed ) throws Exception
594        {
595            if ( expected != null )
596            {
597                Assert.assertNotNull( computed );
598                Assert.assertEquals( expected.getJavaValue( ModulesTest.class.getClassLoader() ),
599                                     computed.getJavaValue( ModulesTest.class.getClassLoader() ) );
600    
601                Assert.assertEquals( expected.getName(), computed.getName() );
602                Assert.assertEquals( expected.getType(), computed.getType() );
603                Assert.assertEquals( expected.getValue(), computed.getValue() );
604                Assert.assertEquals( expected.isDeprecated(), computed.isDeprecated() );
605                Assert.assertEquals( expected.isFinal(), computed.isFinal() );
606                Assert.assertEquals( expected.isOverride(), computed.isOverride() );
607            }
608            else
609            {
610                Assert.assertNull( computed );
611            }
612        }
613    
614        private static void log( final ModelValidationReport report )
615        {
616            for ( ModelValidationReport.Detail d : report.getDetails() )
617            {
618                System.out.println( "\t" + d.toString() );
619            }
620        }
621    
622    }