public void ToBsonValue_should_return_proper_value()
 {
     var wCount = new WriteConcern.WCount(1);
     var bsonValue = wCount.ToBsonValue();
     bsonValue.Should().BeOfType<BsonInt32>();
     bsonValue.AsInt32.Should().Be(1);
 }
 public void ToString_should_return_proper_value()
 {
     var wCount = new WriteConcern.WCount(1);
     wCount.ToString().Should().Be("1");
 }
 public void Equals_should_return_false_if_any_fields_are_not_equal(int w1, int w2)
 {
     var wCount1 = new WriteConcern.WCount(w1);
     var wCount2 = new WriteConcern.WCount(w2);
     wCount1.Equals(wCount2).Should().BeFalse();
     wCount1.Equals((object)wCount2).Should().BeFalse();
     wCount1.GetHashCode().Should().NotBe(wCount2.GetHashCode());
 }
 public void Equals_should_return_true_if_all_fields_are_equal(int w)
 {
     var wCount1 = new WriteConcern.WCount(w);
     var wCount2 = new WriteConcern.WCount(w);
     wCount1.Equals(wCount2).Should().BeTrue();
     wCount1.Equals((object)wCount2).Should().BeTrue();
     wCount1.GetHashCode().Should().Be(wCount2.GetHashCode());
 }
        // public indexers
        /// <summary>
        /// Gets or sets individual settings by keyword.
        /// </summary>
        /// <param name="keyword">The keyword.</param>
        /// <returns>The value of the setting.</returns>
        public override object this[string keyword]
        {
            get
            {
                if (keyword == null) { throw new ArgumentNullException("keyword"); }
                return base[__canonicalKeywords[keyword.ToLower()]];
            }
            set
            {
                if (keyword == null) { throw new ArgumentNullException("keyword"); }
                ReadPreference readPreference;
                switch (keyword.ToLower())
                {
                    case "authprotocol":
                        if (value is string)
                        {
                            AuthenticationProtocol = (MongoAuthenticationProtocol)Enum.Parse(typeof(MongoAuthenticationProtocol), (string)value, true);
                        }
                        else
                        {
                            AuthenticationProtocol = (MongoAuthenticationProtocol)value;
                        }
                        break;
                    case "authsource":
                        AuthenticationSource = (string)value;
                        break;
                    case "connect":
                        if (value is string)
                        {
                            ConnectionMode = (ConnectionMode)Enum.Parse(typeof(ConnectionMode), (string)value, true); // ignoreCase
                        }
                        else
                        {
                            ConnectionMode = (ConnectionMode)value;
                        }
                        break;
                    case "connecttimeout":
                    case "connecttimeoutms":
                        ConnectTimeout = ToTimeSpan(keyword, value);
                        break;
                    case "database":
                        DatabaseName = (string)value;
                        break;
                    case "fsync":
                        FSync = Convert.ToBoolean(value);
                        break;
                    case "guids":
                    case "uuidrepresentation":
                        GuidRepresentation = (GuidRepresentation)Enum.Parse(typeof(GuidRepresentation), (string)value, true); // ignoreCase
                        break;
                    case "ipv6":
                        IPv6 = Convert.ToBoolean(value);
                        break;
                    case "j":
                    case "journal":
                        Journal = Convert.ToBoolean(value);
                        break;
                    case "maxidletime":
                    case "maxidletimems":
                        MaxConnectionIdleTime = ToTimeSpan(keyword, value);
                        break;
                    case "maxlifetime":
                    case "maxlifetimems":
                        MaxConnectionLifeTime = ToTimeSpan(keyword, value);
                        break;
                    case "maxpoolsize":
                        MaxConnectionPoolSize = Convert.ToInt32(value);
                        break;
                    case "minpoolsize":
                        MinConnectionPoolSize = Convert.ToInt32(value);
                        break;
                    case "password":
                        Password = (string)value;
                        break;
                    case "readpreference":
                        readPreference = _readPreference ?? new ReadPreference();
                        if (value is string)
                        {
                            readPreference.ReadPreferenceMode = (ReadPreferenceMode)Enum.Parse(typeof(ReadPreferenceMode), (string)value, true); // ignoreCase
                        }
                        else
                        {
                            readPreference.ReadPreferenceMode = (ReadPreferenceMode)value;
                        }
                        ReadPreference = readPreference;
                        break;
                    case "readpreferencetags":
                        readPreference = _readPreference ?? new ReadPreference();
                        if (value is string)
                        {
                            readPreference.TagSets = ParseReplicaSetTagSets((string)value);
                        }
                        else
                        {
                            readPreference.TagSets = (IEnumerable<ReplicaSetTagSet>)value;
                        }
                        ReadPreference = readPreference;
                        break;
                    case "replicaset":
                        ReplicaSetName = (string)value;
                        break;
                    case "safe":
                        var safe = Convert.ToBoolean(value);
                        if (_w == null)
                        {
                            W = safe ? 1 : 0;
                        }
                        else
                        {
                            if (safe)
                            {
                                // don't overwrite existing W value unless it's 0
                                var wCount = _w as WriteConcern.WCount;
                                if (wCount != null && wCount.Value == 0)
                                {
                                    W = 1;
                                }
                            }
                            else
                            {
                                W = 0;
                            }
                        }
                        break;
                    case "secondaryacceptablelatency":
                    case "secondaryacceptablelatencyms":
                        SecondaryAcceptableLatency = ToTimeSpan(keyword, value);
                        break;
                    case "server":
                    case "servers":
                        Servers = ParseServersString((string)value);
                        break;
                    case "slaveok":
#pragma warning disable 618
                        SlaveOk = Convert.ToBoolean(value);
#pragma warning restore
                        break;
                    case "sockettimeout":
                    case "sockettimeoutms":
                        SocketTimeout = ToTimeSpan(keyword, value);
                        break;
                    case "ssl":
                        UseSsl = Convert.ToBoolean(value);
                        break;
                    case "sslverifycertificate":
                        VerifySslCertificate = Convert.ToBoolean(value);
                        break;
                    case "username":
                        Username = (string)value;
                        break;
                    case "w":
                        if (IsIntegerType(value))
                        {
                            W = new WriteConcern.WCount(Convert.ToInt32(value));
                        }
                        else if (value is string)
                        {
                            W = WriteConcern.WValue.Parse((string)value);
                        }
                        else
                        {
                            W = (WriteConcern.WValue)value;
                        }
                        break;
                    case "waitqueuemultiple":
                        WaitQueueMultiple = Convert.ToDouble(value);
                        break;
                    case "waitqueuesize":
                        WaitQueueSize = Convert.ToInt32(value);
                        break;
                    case "waitqueuetimeout":
                    case "waitqueuetimeoutms":
                        WaitQueueTimeout = ToTimeSpan(keyword, value);
                        break;
                    case "wtimeout":
                    case "wtimeoutms":
                        WTimeout = ToTimeSpan(keyword, value);
                        break;
                    default:
                        var message = string.Format("Invalid keyword '{0}'.", keyword);
                        throw new ArgumentException(message);
                }
            }
        }
 public void Constructor_should_initialize_instance(int w)
 {
     var wCount = new WriteConcern.WCount(w);
     wCount.Value.Should().Be(w);
 }
        public void ToString_should_return_expected_result()
        {
            var subject = new WriteConcern.WCount(1);

            var result = subject.ToString();
            
            result.Should().Be("1");
        }
        public void ToBsonValue_should_return_expected_result()
        {
            var subject = new WriteConcern.WCount(1);

            var result = subject.ToBsonValue();

            result.Should().BeOfType<BsonInt32>();
            result.AsInt32.Should().Be(1);
        }
        public void Equals_should_return_true_if_all_fields_are_equal()
        {
            var subject1 = new WriteConcern.WCount(1);
            var subject2 = new WriteConcern.WCount(1);

            var result1 = subject1.Equals(subject2);
            var result2 = subject1.Equals((object)subject2);
            var hashCode1 = subject1.GetHashCode();
            var hashCode2 = subject2.GetHashCode();

            result1.Should().BeTrue();
            result2.Should().BeTrue();
            hashCode1.Should().Be(hashCode2);
        }
        public void Equals_should_return_false_if_any_fields_are_not_equal()
        {
            var subject1 = new WriteConcern.WCount(0);
            var subject2 = new WriteConcern.WCount(1);

            var result1 = subject1.Equals(subject2);
            var result2 = subject1.Equals((object)subject2);
            var hashCode1 = subject1.GetHashCode();
            var hashCode2 = subject2.GetHashCode();

            result1.Should().BeFalse();
            result2.Should().BeFalse();
            hashCode1.Should().NotBe(hashCode2);
        }
        public void ToString_should_return_expected_value(object w, int? wTimeoutSeconds, bool? fsync, bool? journal, string expected)
        {
            WriteConcern.WValue parsedW;
            if(w == null)
            {
                parsedW = null;
            }
            else if (w is int)
            {
                parsedW = new WriteConcern.WCount((int)w);
            }
            else
            {
                parsedW = new WriteConcern.WMode((string)w);
            }

            var wTimeout = wTimeoutSeconds.HasValue ? (TimeSpan?)TimeSpan.FromSeconds(wTimeoutSeconds.Value) : null;
            var writeConcern = new WriteConcern(parsedW, wTimeout, fsync, journal);
            writeConcern.ToString().Should().Be(expected);
        }