[jira] [Commented] (DELTASPIKE-1001) Skip caching ClassDeactivation for some project stages

["Gerhard Petracek (JIRA)" <ji...@apache.org>]

    [ https://issues.apache.org/jira/browse/DELTASPIKE-1001?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14952903#comment-14952903 ] 

Gerhard Petracek commented on DELTASPIKE-1001:
----------------------------------------------

i don't get why you need 3 new classes for a simple change like:

{code}
public static boolean isActivated(Class<? extends Deactivatable> targetClass)
{
    ProjectStage currentProjectStage = ProjectStageProducer.getInstance().getProjectStage();
    if (currentProjectStage == ProjectStage.UnitTest || currentProjectStage == ProjectStage.Development)
    {
        activationStatusCache.clear();
    }

    //code as it was before
}
{code}

+ your test just tests your new classes and not the overall behavior.
with the change mentioned above you can use the following test to test the overall behavior with:

{code}
public class ProjectStageDependentClassDeactivationTest
{
    @Test
    public void deactivationResultInProjectStageUnitTest()
    {
        ProjectStageProducer.setProjectStage(ProjectStage.UnitTest);

        Class<? extends Deactivatable> classToCheck = DeactivatableForUnitTest.class;
        EditableTestDeactivator.activate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck));

        EditableTestDeactivator.deactivate(classToCheck);
        Assert.assertEquals(false, ClassDeactivationUtils.isActivated(classToCheck));
    }

    @Test
    public void deactivationResultInProjectStageDevelopment()
    {
        ProjectStageProducer.setProjectStage(ProjectStage.Development);

        Class<? extends Deactivatable> classToCheck = DeactivatableForDevelopment.class;
        EditableTestDeactivator.activate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck));

        EditableTestDeactivator.deactivate(classToCheck);
        Assert.assertEquals(false, ClassDeactivationUtils.isActivated(classToCheck));
    }

    @Test
    public void deactivationResultInProjectStageProduction()
    {
        ProjectStageProducer.setProjectStage(ProjectStage.Production);

        Class<? extends Deactivatable> classToCheck = DeactivatableForProduction.class;
        EditableTestDeactivator.activate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck));

        EditableTestDeactivator.deactivate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck)); //due to the cached result
    }

    @Test
    public void deactivationResultInProjectStageIntegrationTest()
    {
        ProjectStageProducer.setProjectStage(ProjectStage.IntegrationTest);

        Class<? extends Deactivatable> classToCheck = DeactivatableForIntegrationTest.class;
        EditableTestDeactivator.activate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck));

        EditableTestDeactivator.deactivate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck)); //due to the cached result
    }

    @Test
    public void deactivationResultInProjectStageStaging()
    {
        ProjectStageProducer.setProjectStage(ProjectStage.Staging);

        Class<? extends Deactivatable> classToCheck = DeactivatableForStaging.class;
        EditableTestDeactivator.activate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck));

        EditableTestDeactivator.deactivate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck)); //due to the cached result
    }

    @Test
    public void deactivationResultInProjectStageSystemTest()
    {
        ProjectStageProducer.setProjectStage(ProjectStage.SystemTest);

        Class<? extends Deactivatable> classToCheck = DeactivatableForSystemTest.class;
        EditableTestDeactivator.activate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck));

        EditableTestDeactivator.deactivate(classToCheck);
        Assert.assertEquals(true, ClassDeactivationUtils.isActivated(classToCheck)); //due to the cached result
    }

    /*
     the tests just need to be consistent within one stage and not across stages
     -> separated classes are just needed, because using a single class will lead to
     getting in cached results of other tests once it isn't project-stage unit-test or development
     */

    private static class DeactivatableForUnitTest implements Deactivatable
    {
    }

    private static class DeactivatableForDevelopment implements Deactivatable
    {
    }

    private static class DeactivatableForProduction implements Deactivatable
    {
    }

    private static class DeactivatableForIntegrationTest implements Deactivatable
    {
    }

    private static class DeactivatableForStaging implements Deactivatable
    {
    }

    private static class DeactivatableForSystemTest implements Deactivatable
    {
    }
}

public class EditableTestDeactivator implements ClassDeactivator
{
    private static Map<Class<? extends Deactivatable>, Boolean> result = new HashMap<Class<? extends Deactivatable>, Boolean>();

    @Override
    public Boolean isActivated(Class<? extends Deactivatable> targetClass)
    {
        return result.get(targetClass);
    }


    public static void activate(Class<? extends Deactivatable> classToActivate)
    {
        result.put(classToActivate, true);
    }

    public static void deactivate(Class<? extends Deactivatable> classToActivate)
    {
        result.put(classToActivate, false);
    }
}
//with
//props.put("org.apache.deltaspike.core.spi.activation.ClassDeactivator","org.apache.deltaspike.core.util.activation.EditableTestDeactivator");
//in TestConfigSource
{code}

> Skip caching ClassDeactivation for some project stages
> ------------------------------------------------------
>
>                 Key: DELTASPIKE-1001
>                 URL: https://issues.apache.org/jira/browse/DELTASPIKE-1001
>             Project: DeltaSpike
>          Issue Type: New Feature
>          Components: Core
>    Affects Versions: 1.5.0
>            Reporter: John D. Ament
>            Assignee: John D. Ament
>             Fix For: 1.5.1
>
>
> Add the ability to skip caching if the project stage is unit test and possibly development.



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)