Back to Repositories

Testing Profile-Based Conditional Configuration in Apollo

This test suite validates Spring profile conditional configurations in Apollo, focusing on the behavior of @ConditionalOnProfile and @ConditionalOnMissingProfile annotations. It verifies profile-based configuration activation and deactivation scenarios in a Spring context environment.

Test Coverage Overview

The test suite provides comprehensive coverage of profile-based conditional configurations.

Key areas tested include:

Single profile activation conditions
Profile absence verification
Multiple profile combinations
Nested configuration scenarios
Boolean state tracking for each configuration

Implementation Analysis

The implementation utilizes Spring’s testing framework with JUnit4 integration. The test class employs @ActiveProfiles to set up the test environment with specific profiles (‘someProfile’ and ‘anotherProfile’). Static boolean flags track the initialization state of each configuration class, providing clear verification points for conditional loading behavior.

Technical Details

Testing tools and configuration:

SpringJUnit4ClassRunner for test execution
@ContextConfiguration for test context setup
Static configuration classes with conditional annotations
JUnit assertions for verification
Multiple nested test configurations for different scenarios

Best Practices Demonstrated

The test demonstrates several testing best practices for Spring conditional configurations.

Notable practices include:

Clear separation of test scenarios through nested classes
Explicit state tracking for verification
Comprehensive coverage of both positive and negative cases
Well-structured test organization using Spring’s testing annotations

apolloconfig/apollo

apollo-common/src/test/java/com/ctrip/framework/apollo/common/conditional/ConditionalOnProfileTest.java

            
/*
 * Copyright 2024 Apollo Authors
 *
 * 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 com.ctrip.framework.apollo.common.conditional;

import com.ctrip.framework.apollo.common.condition.ConditionalOnMissingProfile;
import com.ctrip.framework.apollo.common.condition.ConditionalOnProfile;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static com.ctrip.framework.apollo.common.conditional.ConditionalOnProfileTest.ANOTHER_PROFILE;
import static com.ctrip.framework.apollo.common.conditional.ConditionalOnProfileTest.SOME_PROFILE;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

/**
 * @author Jason Song([email protected])
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ConditionalOnProfileTest.TestConfiguration.class)
@ActiveProfiles({SOME_PROFILE, ANOTHER_PROFILE})
public class ConditionalOnProfileTest {
  static final String SOME_PROFILE = "someProfile";
  static final String ANOTHER_PROFILE = "anotherProfile";
  static final String YET_ANOTHER_PROFILE = "yetAnotherProfile";

  static boolean someConfigurationEnabled = false;
  static boolean anotherConfigurationEnabled = false;
  static boolean yetAnotherConfigurationEnabled = false;
  static boolean combinedConfigurationEnabled = false;
  static boolean anotherCombinedConfigurationEnabled = false;

  @Test
  public void test() throws Exception {
    assertTrue(someConfigurationEnabled);
    assertFalse(anotherConfigurationEnabled);
    assertTrue(yetAnotherConfigurationEnabled);
    assertTrue(combinedConfigurationEnabled);
    assertFalse(anotherCombinedConfigurationEnabled);
  }

  @Configuration
  static class TestConfiguration {

    @Configuration
    @ConditionalOnProfile(SOME_PROFILE)
    static class SomeConfiguration {
      {
        someConfigurationEnabled = true;
      }
    }

    @Configuration
    @ConditionalOnMissingProfile(ANOTHER_PROFILE)
    static class AnotherConfiguration {
      {
        anotherConfigurationEnabled = true;
      }
    }


    @Configuration
    @ConditionalOnMissingProfile(YET_ANOTHER_PROFILE)
    static class YetAnotherConfiguration {
      {
        yetAnotherConfigurationEnabled = true;
      }
    }

    @Configuration
    @ConditionalOnProfile({SOME_PROFILE, ANOTHER_PROFILE})
    @ConditionalOnMissingProfile(YET_ANOTHER_PROFILE)
    static class CombinedConfiguration {
      {
        combinedConfigurationEnabled = true;
      }
    }

    @Configuration
    @ConditionalOnProfile(SOME_PROFILE)
    @ConditionalOnMissingProfile({YET_ANOTHER_PROFILE, ANOTHER_PROFILE})
    static class AnotherCombinedConfiguration {
      {
        anotherCombinedConfigurationEnabled = true;
      }
    }

  }
}