Java Chainr.fromSpec方法代码示例

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包/类
/**
 * 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包/类
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包/类
@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(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( 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
}
 

import com.bazaarvoice.jolt.Chainr; //导入方法依赖的package包/类
@Test( dataProvider = "fromToTests")
public void testChainrIncrementsFromTo( Object chainrSpec, int start, int end ) throws IOException {
    Chainr chainr = Chainr.fromSpec( chainrSpec );

    Object expected = JsonUtils.classpathToObject( "/json/chainr/increments/" + start + "-" + end + ".json" );

    Object actual = chainr.transform( start, end, new HashMap() );

    JoltTestUtil.runDiffy( "failed incremental From-To Chainr", expected, actual );
}