Esempio n. 1
0
        public void BsonBinaryReader_should_support_reading_more_than_2GB()
        {
            RequireEnvironmentVariable.IsDefined("EXPLICIT");

            var binaryData = new BsonBinaryData(new byte[1024 * 1024]);

            var tempFileName = Path.GetTempFileName();

            try
            {
                using (var stream = new FileStream(tempFileName, FileMode.Open))
                {
                    using (var binaryWriter = new BsonBinaryWriter(stream))
                    {
                        while (stream.Position < (long)int.MaxValue * 4)
                        {
                            binaryWriter.WriteStartDocument();
                            binaryWriter.WriteName("x");
                            binaryWriter.WriteBinaryData(binaryData);
                            binaryWriter.WriteEndDocument();
                        }
                    }

                    var endOfFilePosition = stream.Position;
                    stream.Position = 0;

                    using (var binaryReader = new BsonBinaryReader(stream))
                    {
                        while (!binaryReader.IsAtEndOfFile())
                        {
                            binaryReader.ReadStartDocument();
                            var bookmark = binaryReader.GetBookmark();

                            binaryReader.ReadName("x");
                            binaryReader.ReturnToBookmark(bookmark);

                            binaryReader.ReadName("x");
                            var readBinaryData = binaryReader.ReadBinaryData();
                            Assert.Equal(binaryData.Bytes.Length, readBinaryData.Bytes.Length);

                            binaryReader.ReadEndDocument();
                        }
                    }

                    Assert.Equal(endOfFilePosition, stream.Position);
                }
            }
            finally
            {
                try
                {
                    File.Delete(tempFileName);
                }
                catch
                {
                    // ignore exceptions
                }
            }
        }
        public void TestSuccessfulAuthentication()
        {
            RequireEnvironmentVariable.IsDefined("EXPLICIT");
            var client = new MongoClient(_settings);

            var result = client
                         .GetDatabase(DriverTestConfiguration.DatabaseNamespace.DatabaseName)
                         .GetCollection <BsonDocument>(__collectionName)
                         .FindSync(new BsonDocument())
                         .ToList();

            Assert.NotNull(result);
        }
        public void TestNoCredentials()
        {
            RequireEnvironmentVariable.IsDefined("EXPLICIT");
            _settings.Credentials = Enumerable.Empty <MongoCredential>();
            var client = new MongoClient(_settings);

            Assert.Throws <MongoCommandException>(() =>
            {
                client
                .GetDatabase(DriverTestConfiguration.DatabaseNamespace.DatabaseName)
                .GetCollection <BsonDocument>(__collectionName)
                .Count(new BsonDocument());
            });
        }
        public void TestBadPassword()
        {
            RequireEnvironmentVariable.IsDefined("EXPLICIT");
            var currentCredential = _settings.Credentials.Single();

            _settings.Credentials = new[]
            {
                MongoCredential.CreatePlainCredential(currentCredential.Source, currentCredential.Username, "wrongPassword")
            };

            var client = new MongoClient(_settings);

            Assert.Throws <TimeoutException>(() =>
            {
                client
                .GetDatabase(DriverTestConfiguration.DatabaseNamespace.DatabaseName)
                .GetCollection <BsonDocument>(__collectionName)
                .FindSync(new BsonDocument())
                .ToList();
            });
        }
        public void TestWhereEEqualsA()
        {
            RequireEnvironmentVariable.IsDefined("MONO"); // Does not pass on Mono 3.2.5. Excluding for now.
            var query = from c in __collection.AsQueryable <C>()
                        where c.E == E.A
                        select c;

            var translatedQuery = MongoQueryTranslator.Translate(query);

            Assert.IsType <SelectQuery>(translatedQuery);
            Assert.Same(__collection, translatedQuery.Collection);
            Assert.Same(typeof(C), translatedQuery.DocumentType);

            var selectQuery = (SelectQuery)translatedQuery;

            Assert.Equal("(C c) => ((Nullable<Int32>)c.E == (Nullable<Int32>)1)", ExpressionFormatter.ToString(selectQuery.Where));
            Assert.Null(selectQuery.OrderBy);
            Assert.Null(selectQuery.Projection);
            Assert.Null(selectQuery.Skip);
            Assert.Null(selectQuery.Take);

            Assert.Equal("{ \"e\" : \"A\" }", selectQuery.BuildQuery().ToJson());
            Assert.Equal(1, Consume(query));
        }
 public void TestReconnect()
 {
     RequireEnvironmentVariable.IsDefined("EXPLICIT");
     __server.Reconnect();
     Assert.True(__server.State == MongoServerState.Connected || __server.State == MongoServerState.ConnectedToSubset);
 }