/// <summary>
        /// Extension on <see cref="SqlServerStreamConfig"/> to build a <see cref="SqlStream"/>.
        /// </summary>
        /// <param name="streamConfig">The stream configuration object.</param>
        /// <param name="serializerFactory">The serializer factory.</param>
        /// <returns>A <see cref="SqlStream"/>.</returns>
        public static SqlStream ToStream(
            this SqlServerStreamConfig streamConfig,
            ISerializerFactory serializerFactory)
        {
            streamConfig.MustForArg(nameof(streamConfig)).NotBeNull();
            serializerFactory.MustForArg(nameof(serializerFactory)).NotBeNull();

            if (streamConfig.AllLocators.Count != 1)
            {
                throw new NotSupportedException(Invariant($"One single resource locators are currently supported and '{streamConfig.AllLocators.Count}' were provided."));
            }

            var resourceLocatorProtocol = new SingleResourceLocatorProtocols(streamConfig.AllLocators.Single());

            var result = new SqlStream(
                streamConfig.Name,
                streamConfig.DefaultConnectionTimeout,
                streamConfig.DefaultCommandTimeout,
                streamConfig.DefaultSerializerRepresentation,
                streamConfig.DefaultSerializationFormat,
                serializerFactory,
                resourceLocatorProtocol);

            return(result);
        }
Exemplo n.º 2
0
        public void TestConfigStreamBuilding()
        {
            var localStreamName = "MyStream";
            var x = new SqlServerStreamConfig(
                localStreamName,
                StreamAccessKinds.Read,
                TimeSpan.FromSeconds(30),
                TimeSpan.FromSeconds(30),
                new SerializerRepresentation(
                    SerializationKind.Bson,
                    typeof(SqlServerBsonSerializationConfiguration).ToRepresentation().RemoveAssemblyVersions()),
                SerializationFormat.String,
                new[]
            {
                new SqlServerLocator("localhost", "MyDatabase", "user", "password"),
            });
            var serializer = new ObcJsonSerializer(typeof(SqlServerJsonSerializationConfiguration).ToJsonSerializationConfigurationType());
            var output     = serializer.SerializeToString(x);

            var stream = Config.GetByName <SqlServerStreamConfig>(
                localStreamName,
                new SerializerRepresentation(
                    SerializationKind.Json,
                    typeof(SqlServerJsonSerializationConfiguration).ToRepresentation()),
                SerializerFactory.Instance)
                         .ToStream(SerializerFactory.Instance);

            stream.MustForTest().NotBeNull().And().BeOfType <SqlStream>();
        }
        static SqlServerStreamConfigTest()
        {
            ConstructorArgumentValidationTestScenarios
            .AddScenario(() =>
                         new ConstructorArgumentValidationTestScenario <SqlServerStreamConfig>
            {
                Name             = "constructor should throw ArgumentOutRangeException when parameter 'defaultConnectionTimeout' is negative",
                ConstructionFunc = () =>
                {
                    var referenceObject = A.Dummy <SqlServerStreamConfig>();

                    var result = new SqlServerStreamConfig(
                        referenceObject.Name,
                        referenceObject.AccessKinds,
                        referenceObject.DefaultConnectionTimeout.Negate(),
                        referenceObject.DefaultCommandTimeout,
                        referenceObject.DefaultSerializerRepresentation,
                        referenceObject.DefaultSerializationFormat,
                        referenceObject.AllLocators);

                    return(result);
                },
                ExpectedExceptionType            = typeof(ArgumentOutOfRangeException),
                ExpectedExceptionMessageContains = new[] { "defaultConnectionTimeout.TotalMilliseconds" },
            })
            .AddScenario(() =>
                         new ConstructorArgumentValidationTestScenario <SqlServerStreamConfig>
            {
                Name             = "constructor should throw ArgumentOutRangeException when parameter 'defaultConnectionTimeout' is negative",
                ConstructionFunc = () =>
                {
                    var referenceObject = A.Dummy <SqlServerStreamConfig>();

                    var result = new SqlServerStreamConfig(
                        referenceObject.Name,
                        referenceObject.AccessKinds,
                        referenceObject.DefaultConnectionTimeout,
                        referenceObject.DefaultCommandTimeout.Negate(),
                        referenceObject.DefaultSerializerRepresentation,
                        referenceObject.DefaultSerializationFormat,
                        referenceObject.AllLocators);

                    return(result);
                },
                ExpectedExceptionType            = typeof(ArgumentOutOfRangeException),
                ExpectedExceptionMessageContains = new[] { "defaultCommandTimeout.TotalMilliseconds", },
            })
            .AddScenario(() =>
                         new ConstructorArgumentValidationTestScenario <SqlServerStreamConfig>
            {
                Name             = "constructor should throw ArgumentOutRangeException when parameter 'defaultSerializationFormat' is SerializationFormat.Invalid",
                ConstructionFunc = () =>
                {
                    var referenceObject = A.Dummy <SqlServerStreamConfig>();

                    var result = new SqlServerStreamConfig(
                        referenceObject.Name,
                        referenceObject.AccessKinds,
                        referenceObject.DefaultConnectionTimeout,
                        referenceObject.DefaultCommandTimeout,
                        referenceObject.DefaultSerializerRepresentation,
                        SerializationFormat.Invalid,
                        referenceObject.AllLocators);

                    return(result);
                },
                ExpectedExceptionType            = typeof(ArgumentOutOfRangeException),
                ExpectedExceptionMessageContains = new[] { "defaultSerializationFormat", "Invalid", },
            });
        }