public Stream Convert(TestStreamAttribute input)
 {
     if (input.Access == FileAccess.Read)
     {
         return(null); // Simulate not-exist
     }
     throw new InvalidOperationException();
 }
 public Stream Convert(TestStreamAttribute input)
 {
     if (input.Access == FileAccess.Read)
     {
         var value  = input.Path; // Will exercise the [AutoResolve]
         var stream = new MemoryStream(Encoding.UTF8.GetBytes(value));
         stream.Position = 0;
         return(stream);
     }
     throw new InvalidOperationException();
 }
 public async Task <Stream> ConvertAsync(TestStreamAttribute input, CancellationToken cancellationToken)
 {
     if (input.Access == FileAccess.Read)
     {
         var stream = new MemoryStream(Encoding.UTF8.GetBytes("Hello"));
         stream.Position = 0;
         return(stream);
     }
     if (input.Access == FileAccess.Write)
     {
         var stream = new MemoryStream();
         _writeStream = stream;
         return(stream);
     }
     throw new NotImplementedException();
 }
        public void DefaultType()
        {
            var config = TestHelpers.NewConfig <ConfigNullOutParam>();

            config.AddExtension(new ConfigNullOutParam()); // Registers a BindToInput rule
            var host = new JobHost(config);
            IJobHostMetadataProvider metadataProvider = host.CreateMetadataProvider();

            // Getting default type.
            var attr = new TestStreamAttribute("x", FileAccess.Read);
            {
                var defaultType = metadataProvider.GetDefaultType(attr, FileAccess.Read, null);
                Assert.Equal(typeof(Stream), defaultType);
            }

            {
                var defaultType = metadataProvider.GetDefaultType(attr, FileAccess.Write, null);
                Assert.Equal(typeof(Stream), defaultType);
            }
        }
Exemple #5
0
            public Task <Stream> ConvertAsync(TestStreamAttribute input, CancellationToken cancellationToken)
            {
                MemoryStream stream = null;

                if (input.Access == FileAccess.Read)
                {
                    stream = new MemoryStream(Encoding.UTF8.GetBytes("Hello"))
                    {
                        Position = 0
                    };
                }
                else if (input.Access == FileAccess.Write)
                {
                    stream       = new MemoryStream();
                    _writeStream = stream;
                }
                else
                {
                    throw new NotImplementedException();
                }

                return(Task.FromResult <Stream>(stream));
            }
Exemple #6
0
        public void DefaultType()
        {
            var host = new HostBuilder()
                       .ConfigureDefaultTestHost <ConfigNullOutParam>(b =>
            {
                b.AddExtension <ConfigNullOutParam>();
            })
                       .Build();

            IJobHostMetadataProvider metadataProvider = host.CreateMetadataProvider();

            // Getting default type.
            var attr = new TestStreamAttribute("x", FileAccess.Read);

            {
                var defaultType = metadataProvider.GetDefaultType(attr, FileAccess.Read, null);
                Assert.Equal(typeof(Stream), defaultType);
            }

            {
                var defaultType = metadataProvider.GetDefaultType(attr, FileAccess.Write, null);
                Assert.Equal(typeof(Stream), defaultType);
            }
        }
 public Stream Convert(TestStreamAttribute input)
 {
     // Should never even try to create a stream when 'out T' is set to null.
     throw new InvalidOperationException("Test cases should never create stream");
 }