TracingTest.java

/*
 * Copyright 2006 Niclas Hedhman.
 *
 * Licensed  under the  Apache 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.apache.org/licenses/LICENSE-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.qi4j.logging;

import org.junit.Test;
import org.qi4j.api.concern.ConcernOf;
import org.qi4j.api.concern.Concerns;
import org.qi4j.api.mixin.Mixins;
import org.qi4j.api.query.Query;
import org.qi4j.api.query.QueryBuilder;
import org.qi4j.api.service.ServiceComposite;
import org.qi4j.api.unitofwork.UnitOfWork;
import org.qi4j.bootstrap.AssemblyException;
import org.qi4j.bootstrap.ModuleAssembly;
import org.qi4j.index.rdf.assembly.RdfMemoryStoreAssembler;
import org.qi4j.logging.trace.Trace;
import org.qi4j.logging.trace.TraceAllConcern;
import org.qi4j.logging.trace.TraceConcern;
import org.qi4j.logging.trace.assemblies.TracingAssembler;
import org.qi4j.logging.trace.records.CompositeTraceRecordEntity;
import org.qi4j.logging.trace.records.EntityTraceRecordEntity;
import org.qi4j.logging.trace.records.ServiceTraceRecordEntity;
import org.qi4j.logging.trace.records.TraceRecord;
import org.qi4j.spi.uuid.UuidIdentityGeneratorService;
import org.qi4j.test.AbstractQi4jTest;

import java.util.Iterator;
import org.qi4j.test.EntityTestAssembler;

import static org.junit.Assert.*;
import static org.qi4j.api.query.QueryExpressions.orderBy;
import static org.qi4j.api.query.QueryExpressions.templateFor;

public class TracingTest
    extends AbstractQi4jTest
{
    public void assemble( ModuleAssembly module )
        throws AssemblyException
    {
        module.services( SomeService.class ).instantiateOnStartup();
        module.services( SomeService2.class ).instantiateOnStartup();
        new TracingAssembler().assemble( module );
        new EntityTestAssembler().assemble( module );
        new RdfMemoryStoreAssembler().assemble( module );
        module.services( UuidIdentityGeneratorService.class );
        module.entities( CompositeTraceRecordEntity.class );
        module.entities( EntityTraceRecordEntity.class );
        module.entities( ServiceTraceRecordEntity.class );
    }

    @Test
    public void whenTraceOnMixinTypeMethodExpectOneEntryInEntityStore()
        throws Exception
    {
        SomeService sc = module.findService( SomeService.class ).get();
        assertEquals( 123, sc.doSomethingImportant() );
        assertEquals( 456, sc.doSomethingLessImportant() );
        UnitOfWork uow = module.newUnitOfWork();
        QueryBuilder<TraceRecord> builder = module.newQueryBuilder( TraceRecord.class );
        Query<TraceRecord> query = uow.newQuery( builder );
        // IS sorting needed??
//        TraceRecord template = templateFor( TraceRecord.class );
//        query.orderBy( orderBy( template.methodName() ) );
        Iterator<TraceRecord> result = query.iterator();
        assertTrue( result.hasNext() );
        TraceRecord rec1 = result.next();
        assertEquals( "doSomethingImportant", rec1.methodName().get() );
        assertFalse( result.hasNext() );
        uow.complete();
    }

    @Test
    public void whenTraceAllOnCompositeTypeExpectTwoEntryInEntityStore()
        throws Exception
    {
        SomeService2 sc = module.findService( SomeService2.class ).get();
        assertEquals( 123, sc.doSomethingImportant() );
        assertEquals( 456, sc.doSomethingLessImportant() );
        UnitOfWork uow = module.newUnitOfWork();
        QueryBuilder<TraceRecord> builder = module.newQueryBuilder( TraceRecord.class );
        Query<TraceRecord> query = uow.newQuery( builder );
        // IS sorting needed??
//        TraceRecord template = templateFor( TraceRecord.class );
//        query.orderBy( orderBy( template.methodName() ) );
        Iterator<TraceRecord> result = query.iterator();
        assertTrue( result.hasNext() );
        TraceRecord rec1 = result.next();
        assertEquals( "doSomethingImportant", rec1.methodName().get() );
        assertTrue( result.hasNext() );
        TraceRecord rec2 = result.next();
        assertEquals( "doSomethingLessImportant", rec2.methodName().get() );
        assertFalse( result.hasNext() );
        uow.complete();
    }

    @Test
    public void whenTraceOnMixinImplExpectTwoEntryInEntityStore()
        throws Exception
    {
        SomeService sc = module.findService( SomeService.class ).get();
        assertEquals( 123, sc.doSomethingImportant() );
        assertEquals( 789, sc.doSomethingModeratelyImportant() );
        UnitOfWork uow = module.newUnitOfWork();
        try
        {
            QueryBuilder<TraceRecord> builder = module.newQueryBuilder( TraceRecord.class );
            Query<TraceRecord> query = uow.newQuery( builder );
            // IS sorting needed??
            TraceRecord template = templateFor( TraceRecord.class );
            query.orderBy( orderBy( template.methodName() ) );
            Iterator<TraceRecord> result = query.iterator();
            assertTrue( result.hasNext() );
            TraceRecord rec1 = result.next();
            assertEquals( "doSomethingImportant", rec1.methodName().get() );
            assertTrue( result.hasNext() );
            TraceRecord rec2 = result.next();
            assertEquals( "doSomethingModeratelyImportant", rec2.methodName().get() );
            assertFalse( result.hasNext() );
            uow.complete();
        }
        catch( Exception e )
        {
            uow.discard();
            throw e;
        }
        catch( Error e )
        {
            uow.discard();
            throw e;
        }
    }

    @Test
    public void whenTraceOnConcernExpectOneEntryInEntityStore()
        throws Exception
    {
        // It is not possible to put Annotation on Concern Methods, so it should only record one.

        SomeService sc = module.findService( SomeService.class ).get();
        assertEquals( 123, sc.doSomethingImportant() );
        assertEquals( 753, sc.doSomethingInsanelyImportant() );
        UnitOfWork uow = module.newUnitOfWork();
        QueryBuilder<TraceRecord> builder = module.newQueryBuilder( TraceRecord.class );
        Query<TraceRecord> query = uow.newQuery( builder );
        // IS sorting needed??
//        TraceRecord template = templateFor( TraceRecord.class );
//        query.orderBy( orderBy( template.methodName() ) );
        Iterator<TraceRecord> result = query.iterator();
        assertTrue( result.hasNext() );
        TraceRecord rec1 = result.next();
        assertEquals( "doSomethingImportant", rec1.methodName().get() );
        assertFalse( result.hasNext() );
        uow.complete();
    }

    @Mixins( SomeMixin.class )
    @Concerns( { SomeConcern.class, TraceConcern.class } )
    public interface SomeService
        extends Some, ServiceComposite
    {
    }

    @Mixins( SomeMixin.class )
    @Concerns( { SomeConcern.class, TraceAllConcern.class } )
    public interface SomeService2
        extends Some, ServiceComposite
    {
    }

    public interface Some
    {
        @Trace
        int doSomethingImportant();

        int doSomethingLessImportant();

        int doSomethingModeratelyImportant();

        int doSomethingInsanelyImportant();
    }

    public static class SomeConcern
        extends ConcernOf<Some>
        implements Some
    {
        public int doSomethingImportant()
        {
            System.out.println( "-- doSomethingImportant()" );
            return next.doSomethingImportant();
        }

        public int doSomethingLessImportant()
        {
            System.out.println( "-- doSomethingLessImportant()" );
            return next.doSomethingLessImportant();
        }

        public int doSomethingModeratelyImportant()
        {
            System.out.println( "-- doSomethingLessImportant()" );
            return next.doSomethingModeratelyImportant();
        }

        @Trace
        public int doSomethingInsanelyImportant()
        {
            System.out.println( "-- doSomethingInsanelyImportant()" );
            return next.doSomethingInsanelyImportant();
        }
    }

    public static class SomeMixin
        implements Some
    {

        public int doSomethingImportant()
        {
            System.out.println( "---- doSomethingImportant()" );
            return 123;
        }

        public int doSomethingLessImportant()
        {
            System.out.println( "---- doSomethingLessImportant()" );
            return 456;
        }

        @Trace
        public int doSomethingModeratelyImportant()
        {
            System.out.println( "---- doSomethingModeratelyImportant()" );
            return 789;
        }

        public int doSomethingInsanelyImportant()
        {
            System.out.println( "---- doSomethingInsanelyImportant()" );
            return 753;
        }
    }
}