import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( expectedExceptions = SpecException.class )
public void itBlowsUpForMissingProviderStockTransform() throws IOException
{
    String testPath = "/json/chainr/guice_spec.json";
    Map<String, Object> testUnit = JsonUtils.classpathToMap( testPath );

    Object spec = testUnit.get( "spec" );

    Module parentModule = new AbstractModule() {
        @Override
        protected void configure() {
        }

        @Provides
        public GuiceSpecDrivenTransform.GuiceConfig getConfigD() {
            return new GuiceSpecDrivenTransform.GuiceConfig( "dd" );
        }
    };

    Chainr.fromSpec( spec, new GuiceChainrInstantiator( parentModule ) );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( expectedExceptions = SpecException.class )
public void itBlowsUpForMissingProviderSpecTransform() throws IOException
{
    String testPath = "/json/chainr/guice_spec.json";
    Map<String, Object> testUnit = JsonUtils.classpathToMap( testPath );

    Object spec = testUnit.get( "spec" );

    Module parentModule = new AbstractModule() {
        @Override
        protected void configure() {
        }

        @Provides
        public GuiceTransform.GuiceConfig getConfigC() {
            return new GuiceTransform.GuiceConfig( "c", "cc" );
        }
    };

    Chainr.fromSpec( spec, new GuiceChainrInstantiator( parentModule ) );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
private Class<? extends JoltTransform> loadJoltTransformClass(ClassLoader classLoader) {

        try {
            Class opClass = classLoader.loadClass( operationClassName );

            if ( Chainr.class.isAssignableFrom( opClass ) ) {
                throw new SpecException( "Attempt to nest Chainr inside itself" + getErrorMessageIndexSuffix() );
            }

            if ( ! JoltTransform.class.isAssignableFrom( opClass ) )
            {
                throw new SpecException( "JOLT Chainr class:" + operationClassName + " does not implement the JoltTransform interface" + getErrorMessageIndexSuffix() );
            }

            @SuppressWarnings( "unchecked" ) // We know it is some type of Transform due to the check above
            Class<? extends JoltTransform> transformClass = (Class<? extends JoltTransform>) opClass;

            return transformClass;

        } catch ( ClassNotFoundException e ) {
            throw new SpecException( "JOLT Chainr could not find transform class:" + operationClassName + getErrorMessageIndexSuffix(), e );
        }
    }
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
/**
 * Load the JSON template data and convert it.
 */
private static void convertJmhJsonData(InputStream specIn, InputStream jmhIn, OutputStream out) throws IOException {
  List<?> chainrConfig = JsonUtils.jsonToList(specIn);
  Chainr chainr = Chainr.fromSpec(chainrConfig);
  List<Object> input = JsonUtils.jsonToList(jmhIn);
  Object jsonOutput = chainr.transform(input);
  out.write(JsonUtils.toJsonString(jsonOutput).getBytes(StandardCharsets.UTF_8));
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
private synchronized Transform getTransform() throws Exception {
    if (transform == null) {
        if (log.isDebugEnabled()) {
            String path = getResourceUri();
            log.debug("Jolt content read from resource {} with resourceUri: {} for endpoint {}", new Object[]{getResourceUri(), path, getEndpointUri()});
        }

        // Sortr does not require a spec
        if (this.transformDsl == JoltTransformType.Sortr) {
            this.transform = new Sortr();
        } else {
            // getResourceAsInputStream also considers the content cache
            Object spec = JsonUtils.jsonToObject(getResourceAsInputStream());
            switch(this.transformDsl) {
            case Shiftr:
                this.transform = new Shiftr(spec);
                break;
            case Defaultr:
                this.transform = new Defaultr(spec);
                break;
            case Removr:
                this.transform = new Removr(spec);
                break;
            case Chainr:
            default:
                this.transform = Chainr.fromSpec(spec);
                break;
            }
        }
        
    }
    return transform;
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@NotNull
private InputStream transform(@NotNull InputStream content, @NotNull RequestConfiguration configuration) {
    if (StringUtil.isNotEmpty(configuration.getTransform())) {
        List chainrSpecJSON = JsonUtils.jsonToList(configuration.getTransform());
        Chainr chainr = Chainr.fromSpec(chainrSpecJSON);
        Object inputJSON = JsonUtils.jsonToObject(content);
        Object transformedOutput = chainr.transform(inputJSON);

        return new ByteArrayInputStream(JsonUtils.toJsonString(transformedOutput).getBytes(StandardCharsets.UTF_8));
    } else {
        return content;
    }
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
public String migrate(String oldJSON, int targetVersion) {
    LOGGER.debug("Migrating to version {}: {}", targetVersion, oldJSON);

    Chainr transform = getTransformerFor(targetVersion);
    Object transformedObject = transform.transform(JsonUtils.jsonToMap(oldJSON));
    String transformedJSON = JsonUtils.toJsonString(transformedObject);

    LOGGER.debug("After migration to version {}: {}", targetVersion, transformedJSON);
    return transformedJSON;
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
private Chainr getTransformerFor(int targetVersion) {
    try {
        String targetVersionFile = String.format("/config-repo/migrations/%s.json", targetVersion);
        String transformJSON = IOUtils.toString(this.getClass().getResourceAsStream(targetVersionFile), "UTF-8");
        return Chainr.fromSpec(JsonUtils.jsonToList(transformJSON));
    } catch (Exception e) {
        throw new RuntimeException("Failed to migrate to version " + targetVersion, e);
    }
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( dataProvider = "getCases")
public void successCases( String testCaseName, Object spec, Object input, Map<String,Object> context, Object expected ) throws IOException {

    Module parentModule = new AbstractModule() {
        @Override
        protected void configure() {
        }

        @Provides
        public GuiceContextDrivenTransform.GuiceConfig getConfigC() {
            return new GuiceContextDrivenTransform.GuiceConfig( "c", "cc" );
        }

        @Provides
        public GuiceSpecAndContextDrivenTransform.GuiceConfig getConfigD() {
            return new GuiceSpecAndContextDrivenTransform.GuiceConfig( "dd" );
        }
    };

    Chainr unit = Chainr.fromSpec( spec, new GuiceChainrInstantiator( parentModule ) );

    Assert.assertTrue( unit.hasContextualTransforms() );
    Assert.assertEquals( unit.getContextualTransforms().size(), 2 );

    Object actual = unit.transform( input, context );

    JoltTestUtil.runDiffy( "failed case " + testCaseName, expected, actual );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test
public void successTestCase() throws IOException {

    String testPath = "/json/chainr/guice_spec.json";
    Map<String, Object> testUnit = JsonUtils.classpathToMap( testPath );

    Object input = testUnit.get( "input" );
    Object spec = testUnit.get( "spec" );
    Object expected = testUnit.get( "expected" );

    Module parentModule = new AbstractModule() {
        @Override
        protected void configure() {
        }

        @Provides
        public GuiceTransform.GuiceConfig getConfigC() {
            return new GuiceTransform.GuiceConfig( "c", "cc" );
        }

        @Provides
        public GuiceSpecDrivenTransform.GuiceConfig getConfigD() {
            return new GuiceSpecDrivenTransform.GuiceConfig( "dd" );
        }
    };

    Chainr unit = Chainr.fromSpec( spec, new GuiceChainrInstantiator( parentModule ) );

    Assert.assertFalse( unit.hasContextualTransforms() );
    Assert.assertEquals( unit.getContextualTransforms().size(), 0 );

    Object actual = unit.transform( input, null );

    JoltTestUtil.runDiffy( "failed case " + testPath, expected, actual );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( expectedExceptions = SpecException.class )
public void itBlowsUpForBadGuiceTransform() {
    Chainr.fromSpec( ImmutableList.of( ImmutableMap.of( "operator", "com.bazaarvoice.jolt.chainr.transforms.GuiceTransformMissingInjectAnnotation" ) ),
            new GuiceChainrInstantiator( new AbstractModule() {
                @Override
                protected void configure() {
                }

                @Provides
                public GuiceTransformMissingInjectAnnotation.BadGuiceConfig getConfigC() {
                    return new GuiceTransformMissingInjectAnnotation.BadGuiceConfig( "b:", "bad" );
                }
            } ) );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
public Chainr build() {
    ChainrSpec chainrSpec = new ChainrSpec( chainrSpecObj, classLoader );
    List<JoltTransform> transforms = new ArrayList<>( chainrSpec.getChainrEntries().size() );
    for ( ChainrEntry entry : chainrSpec.getChainrEntries() ) {

        JoltTransform transform = chainrInstantiator.hydrateTransform( entry );
        transforms.add( transform );
    }

    return new Chainr( transforms );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test(dataProvider = "passingTestCases" )
public void testPassing(Object input, Object spec) {
    Chainr unit = Chainr.fromSpec( spec );
    TransformTestResult actual = (TransformTestResult) unit.transform( input, null );

    Assert.assertEquals( input, actual.input );
    Assert.assertNotNull( actual.spec );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( expectedExceptions = SpecException.class )
public void failsOnStupidTransform() {
    List<JoltTransform> badSpec = Lists.newArrayList();

    // Stupid JoltTransform that implements the base interface, and not one of the useful ones
    badSpec.add( new JoltTransform() {} );

    new Chainr( badSpec );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( expectedExceptions = SpecException.class )
public void failsOnOverEagerTransform() {
    List<JoltTransform> badSpec = Lists.newArrayList();

    // Stupid JoltTransform that implements both "real" interfaces
    badSpec.add( new OverEagerTransform() );

    new Chainr( badSpec );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test(dataProvider = "badFormatSpecs", expectedExceptions = SpecException.class )
public void staticChainrMethod(Object chainrSpec) {
    Chainr.fromSpec( chainrSpec ); // should fail when parsing spec
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test(dataProvider = "badTransforms", expectedExceptions = TransformException.class )
public void testBadTransforms(Object chainrSpec) {
    Chainr unit = Chainr.fromSpec( chainrSpec );
    unit.transform( new HashMap(), null );// should fail here
    Assert.fail( "Should not have gotten here" );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( expectedExceptions = IllegalArgumentException.class )
public void failsOnNullListOfJoltTransforms() {
    new Chainr( null );
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test( dataProvider = "failTests", expectedExceptions = TransformException.class)
public void testFails( Object chainrSpec, int start, int end  ) throws IOException {
    Chainr chainr = Chainr.fromSpec( chainrSpec );
    chainr.transform( start, end, new HashMap());
}
 

import com.bazaarvoice.jolt.Chainr; //导入依赖的package包/类
@Test(dataProvider = "badFormatSpecs", expectedExceptions = SpecException.class )
public void staticChainrMethod( Object chainrSpec ) {
    Chainr.fromSpec( chainrSpec ); // should fail when parsing spec
}