public void Update_with_valid_passstore()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);
            var model   = new PasswordStoreModel()
            {
                Key        = "key-1",
                Name       = "name-1",
                PassPhrase = "somepwd"
                ,
                IsEncrypted = true,
                EncryptedBy = "1"
            };

            // act
            var rslt = mrepo.Update(model)
                       .GetAwaiter().GetResult();

            // assert
            mclient.VerifyAll();
            mcollection.Verify(mc => mc.UpdateOneAsync(It.IsAny <FilterDefinition <PasswordStoreModel> >(),
                                                       It.IsAny <UpdateDefinition <PasswordStoreModel> >(), default(UpdateOptions), default(CancellationToken)),
                               Times.Once);
        }
        public void GetItemsByCategory_with_invalid_data()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act and assert
            Assert.Throws <ArgumentNullException>(() => mrepo.GetItemsByCategory(null)
                                                  .GetAwaiter().GetResult());
        }
        public void GetByKeyName_with_inalid_key()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act and assert
            Assert.Throws <ArgumentNullException>(() => mrepo.GetByKeyName(" ")
                                                  .GetAwaiter().GetResult());

            Assert.Throws <ArgumentNullException>(() => mrepo.GetByKeyName(null)
                                                  .GetAwaiter().GetResult());
        }
        public void AddStoreItem_with_invalid_data()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act and assert
            Assert.Throws <ArgumentNullException>(() => mrepo.AddStoreItem("", new StoreItemModel()
            {
                Title = "title", UserName = "******", Password = "******"
            })
                                                  .GetAwaiter().GetResult());

            Assert.Throws <ArgumentNullException>(() => mrepo.AddStoreItem("key-1", default(StoreItemModel))
                                                  .GetAwaiter().GetResult());
        }
        public void GetItemsByCategory_with_valid_store_model()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act
            var rslt = mrepo.GetItemsByCategory("key-217533")
                       .GetAwaiter().GetResult();

            // assert
            mclient.VerifyAll();
            mcollection.Verify(mc => mc.AggregateAsync(It.IsAny <PipelineDefinition <PasswordStoreModel, PasswordsCategory> >(),
                                                       default(AggregateOptions), default(CancellationToken)),
                               Times.Once);
        }
        public void GetByKeyName_with_valid_key()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act
            var rslt = mrepo.GetByKeyName("key-1123")
                       .GetAwaiter().GetResult();

            // assert
            mclient.VerifyAll();
            mcollection.Verify(mc => mc.FindAsync(It.IsAny <FilterDefinition <PasswordStoreModel> >(),
                                                  default(FindOptions <PasswordStoreModel>), default(CancellationToken)),
                               Times.Once);
        }
        public void GetAll()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act
            var rslt = mrepo.GetAll()
                       .GetAwaiter().GetResult();

            // assert
            mclient.VerifyAll();
            mcollection.Verify(mc => mc.FindAsync(FilterDefinition <PasswordStoreModel> .Empty,
                                                  default(FindOptions <PasswordStoreModel>), default(CancellationToken)),
                               Times.Once);
        }
        public void AddStoreItem_with_valid_store_model()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act
            var rslt = mrepo.AddStoreItem("key-1", new StoreItemModel()
            {
                Title = "title", UserName = "******", Password = "******"
            })
                       .GetAwaiter().GetResult();

            // assert
            mclient.VerifyAll();
            mcollection.Verify(mc => mc.UpdateOneAsync(It.IsAny <FilterDefinition <PasswordStoreModel> >(),
                                                       It.IsAny <UpdateDefinition <PasswordStoreModel> >(), default(UpdateOptions), default(CancellationToken)),
                               Times.Exactly(2));
        }
        public void Delete_with_valid_data()
        {
            // arrange
            var mclient = GetMockClient(out Mock <IMongoCollection <PasswordStoreModel> > mcollection);
            var mrepo   = new PassStoreMongo(mclient.Object);

            // act
            var model = new PasswordStoreModel()
            {
                Key = "key-1", Name = "name-1", PassPhrase = "somepwd"
            };
            var rslt = mrepo.Delete(model)
                       .GetAwaiter().GetResult();

            // assert
            mclient.VerifyAll();
            mcollection.Verify(mc => mc.FindOneAndDeleteAsync(It.IsAny <FilterDefinition <PasswordStoreModel> >(),
                                                              default(FindOneAndDeleteOptions <PasswordStoreModel, PasswordStoreModel>), default(CancellationToken)), Times.Once);
        }
コード例 #10
0
        void ConfigRepos(IServiceCollection services)
        {
            IPassStoreRepo <PasswordStoreModel> repo = null;

            var repos  = Configuration.GetSection("Repos").Get <string[]>();
            var option = int.Parse(Configuration.GetValue <string>("PreferredRepo"));

            if (repos[option - 1].Equals("mongo", StringComparison.OrdinalIgnoreCase))
            {
                var cs = Configuration.GetSection("Mongo").GetValue <string>("DbConnection");
                var di = cs.LastIndexOf("/");
                var db = cs?.Substring(di + 1, cs.IndexOf("?") - di - 1);
                repo = new PassStoreMongo(new MongoClient(cs), db);
            }

            services.AddSingleton <IPassStoreRepo <PasswordStoreModel> >(repo ?? new PassStoreInMemory());

            new TaskFactory().StartNew(() => {
                LoadTestData(services);
            });
        }