Exemplo n.º 1
0
        public async Task NullExpressionOnDeleteTest()
        {
            MongodbConfig            mongodbConfig    = MongoDbHelper.GetMongodbConfig();
            IMongoDatabase           database         = MongodbProvider.GetDatabase(mongodbConfig);
            IDeleteRepository <Test> deleteRepository = new MongodbDeleteRepository <Test>(database);

            await Assert.ThrowsAsync <ArgumentNullException>(() => deleteRepository.DeleteAllByConditionsAsync(null));
        }
Exemplo n.º 2
0
        public async Task NothingToDeleteTest()
        {
            MongodbConfig            mongodbConfig    = MongoDbHelper.GetMongodbConfig();
            IMongoDatabase           database         = MongodbProvider.GetDatabase(mongodbConfig);
            IDeleteRepository <Test> deleteRepository = new MongodbDeleteRepository <Test>(database);

            await deleteRepository.DeleteAllByConditionsAsync(x => x.ObjectId == "non-existent-object");
        }
Exemplo n.º 3
0
        public static IDeleteRepository <T> BuildAndGetDeleteRepository <T>(Tech tech, IConfiguration configuration)
        {
            IDeleteRepository <T> deleteRepository = null;

            switch (tech)
            {
            case Tech.Mongodb:
                deleteRepository = new MongodbDeleteRepository <T>(GetMongoDatabase(configuration));
                break;
            }

            return(deleteRepository);
        }
Exemplo n.º 4
0
        public async Task MultipleEntityIntegralTest()
        {
            MongodbConfig  mongodbConfig = MongoDbHelper.GetMongodbConfig();
            IMongoDatabase database      = MongodbProvider.GetDatabase(mongodbConfig);
            IMongodbSaveRepository <Test> saveRepository   = new MongodbSaveRepository <Test>(database);
            IGetRepository <Test>         getRepository    = new MongodbGetRepository <Test>(database);
            IDeleteRepository <Test>      deleteRepository = new MongodbDeleteRepository <Test>(database);

            Test newTest1 = new Test()
            {
                BoolField      = true,
                NumberField    = 1,
                ObjectId       = Guid.NewGuid().ToString(),
                StringField    = "multiple-object-1",
                TimestampField = DateTime.UtcNow
            };

            Test newTest2 = new Test()
            {
                BoolField      = true,
                NumberField    = 2,
                ObjectId       = Guid.NewGuid().ToString(),
                StringField    = "multiple-object-2",
                TimestampField = DateTime.UtcNow.AddMinutes(1)
            };

            IList <Test> newTests = new List <Test>()
            {
                newTest1, newTest2
            };

            await saveRepository.InsertManyAsync(newTests);

            IEnumerable <Test> savedTests = await getRepository.GetAllByConditionsAsync(x =>
                                                                                        x.ObjectId == newTest1.ObjectId ||
                                                                                        x.ObjectId == newTest2.ObjectId);

            Assert.True(savedTests.Count() == 2);

            Test savedTest1 = savedTests.Single(x =>
                                                x.ObjectId == newTest1.ObjectId &&
                                                x.NumberField == newTest1.NumberField &&
                                                x.StringField == newTest1.StringField &&
                                                DateTimeHelper.AreEquals(x.TimestampField, newTest1.TimestampField) &&
                                                x.BoolField == newTest1.BoolField);

            Test savedTest2 = savedTests.Single(x =>
                                                x.ObjectId == newTest2.ObjectId &&
                                                x.NumberField == newTest2.NumberField &&
                                                x.StringField == newTest2.StringField &&
                                                DateTimeHelper.AreEquals(x.TimestampField, newTest2.TimestampField) &&
                                                x.BoolField == newTest2.BoolField);

            string modifiedStringField = "modified-multiple-objects";
            UpdateDefinition <Test> updateDefinition = Builders <Test> .Update.Set(x => x.StringField, modifiedStringField);

            await saveRepository.UpdateManyAsync(
                x =>
                x.ObjectId == newTest1.ObjectId ||
                x.ObjectId == newTest2.ObjectId,
                updateDefinition);

            IEnumerable <Test> modifiedTests = await getRepository.GetAllByConditionsAsync(x =>
                                                                                           x.StringField == modifiedStringField &&
                                                                                           (x.ObjectId == savedTest1.ObjectId || x.ObjectId == savedTest2.ObjectId));

            Assert.True(modifiedTests.Count() == 2);

            Test modifiedTest1 = modifiedTests.Single(x =>
                                                      x.ObjectId == newTest1.ObjectId &&
                                                      x.NumberField == newTest1.NumberField &&
                                                      x.StringField == modifiedStringField &&
                                                      DateTimeHelper.AreEquals(x.TimestampField, newTest1.TimestampField) &&
                                                      x.BoolField == newTest1.BoolField);

            Test modifiedTest2 = modifiedTests.Single(x =>
                                                      x.ObjectId == newTest2.ObjectId &&
                                                      x.NumberField == newTest2.NumberField &&
                                                      x.StringField == modifiedStringField &&
                                                      DateTimeHelper.AreEquals(x.TimestampField, newTest2.TimestampField) &&
                                                      x.BoolField == newTest2.BoolField);

            await deleteRepository.DeleteAllByConditionsAsync(x =>
                                                              x.StringField == modifiedStringField);

            IEnumerable <Test> deletedTests = await getRepository.GetAllByConditionsAsync(x => x.StringField == modifiedStringField);

            Assert.True(deletedTests == null || deletedTests.Count() == 0);
        }
Exemplo n.º 5
0
        public async Task SingleEntityIntegralTest()
        {
            MongodbConfig  mongodbConfig = MongoDbHelper.GetMongodbConfig();
            IMongoDatabase database      = MongodbProvider.GetDatabase(mongodbConfig);
            IMongodbSaveRepository <Test> saveRepository   = new MongodbSaveRepository <Test>(database);
            IGetRepository <Test>         getRepository    = new MongodbGetRepository <Test>(database);
            IDeleteRepository <Test>      deleteRepository = new MongodbDeleteRepository <Test>(database);

            Test newTest = new Test()
            {
                BoolField      = true,
                NumberField    = 1,
                ObjectId       = Guid.NewGuid().ToString(),
                StringField    = "new-single-object",
                TimestampField = DateTime.UtcNow
            };

            await saveRepository.InsertAsync(newTest);

            Test savedTest = await getRepository.GetFirstByConditionsAsync(x =>
                                                                           x.ObjectId == newTest.ObjectId &&
                                                                           x.BoolField == newTest.BoolField &&
                                                                           x.NumberField == newTest.NumberField &&
                                                                           x.StringField == newTest.StringField &&
                                                                           x.TimestampField == newTest.TimestampField);

            savedTest.BoolField      = false;
            savedTest.NumberField    = 2;
            savedTest.StringField    = "modified-single-object";
            savedTest.TimestampField = DateTime.UtcNow.AddDays(1);

            await saveRepository.ReplaceAsync(
                x =>
                x.ObjectId == newTest.ObjectId &&
                x.BoolField == newTest.BoolField &&
                x.NumberField == newTest.NumberField &&
                x.StringField == newTest.StringField &&
                x.TimestampField == newTest.TimestampField,
                savedTest);

            Test modifiedTest = (await getRepository.GetAllByConditionsAsync(x =>
                                                                             x.ObjectId == savedTest.ObjectId &&
                                                                             x.BoolField == savedTest.BoolField &&
                                                                             x.NumberField == savedTest.NumberField &&
                                                                             x.StringField == savedTest.StringField &&
                                                                             x.TimestampField == savedTest.TimestampField)).Single();

            await deleteRepository.DeleteAllByConditionsAsync(x =>
                                                              x.ObjectId == savedTest.ObjectId &&
                                                              x.BoolField == savedTest.BoolField &&
                                                              x.NumberField == savedTest.NumberField &&
                                                              x.StringField == savedTest.StringField &&
                                                              x.TimestampField == savedTest.TimestampField);

            Test deletedTest = await getRepository.GetFirstByConditionsAsync(x =>
                                                                             x.ObjectId == savedTest.ObjectId &&
                                                                             x.BoolField == savedTest.BoolField &&
                                                                             x.NumberField == savedTest.NumberField &&
                                                                             x.StringField == savedTest.StringField &&
                                                                             x.TimestampField == savedTest.TimestampField);

            Assert.Null(deletedTest);
        }