public FileBackedStateManager(ILogger <IStateManager <T> > logger,
                                      IOptions <FileBackedConfig <FileBackedStateManager <T> > > options,
                                      FileBackedConfigValidator <FileBackedStateManager <T> > fileBackedConfigValidator,
                                      IFileSystem fileSystem)
            : base(logger)
        {
            _logger                    = logger ?? throw new ArgumentNullException(nameof(logger));
            _fileBackedConfig          = options?.Value ?? throw new ArgumentNullException(nameof(options));
            _fileBackedConfigValidator = fileBackedConfigValidator ?? throw new ArgumentNullException(nameof(fileBackedConfigValidator));
            _fileSystem                = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));

            _fileBackedConfigValidator.ValidateAndThrow(_fileBackedConfig);
        }
Exemple #2
0
        public FileBackedInstalledAppManager(ILogger <IInstalledAppManager> logger,
                                             ISmartThingsAPIHelper smartThingsAPIHelper,
                                             IOptions <FileBackedConfig <FileBackedInstalledAppManager> > options,
                                             FileBackedConfigValidator <FileBackedInstalledAppManager> fileBackedConfigValidator,
                                             IFileSystem fileSystem)
            : base(logger, smartThingsAPIHelper)
        {
            _logger = logger ??
                      throw new ArgumentNullException(nameof(logger));
            _fileBackedConfig          = options?.Value ?? throw new ArgumentNullException(nameof(options));
            _fileBackedConfigValidator = fileBackedConfigValidator ?? throw new ArgumentNullException(nameof(fileBackedConfigValidator));
            _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));

            _fileBackedConfigValidator.ValidateAndThrow(_fileBackedConfig);
        }
Exemple #3
0
        public FileBackedTests(ITestOutputHelper output)
        {
            _mockIALogger    = new Mock <ILogger <IInstalledAppManager> >();
            _mockStateLogger = new Mock <ILogger <IStateManager <string> > >();
            _mockIALogger.Setup(log => log.Log(It.IsAny <Microsoft.Extensions.Logging.LogLevel>(),
                                               It.IsAny <EventId>(),
                                               It.IsAny <object>(),
                                               null,
                                               It.IsAny <Func <object, Exception, string> >()))
            .Callback <Microsoft.Extensions.Logging.LogLevel,
                       EventId,
                       object,
                       Exception,
                       Func <object, Exception, string> >((logLevel, e, state, ex, f) =>
            {
                output.WriteLine($"{logLevel} logged: \"{state}\"");
            });
            _mockStateLogger.Setup(log => log.Log(It.IsAny <Microsoft.Extensions.Logging.LogLevel>(),
                                                  It.IsAny <EventId>(),
                                                  It.IsAny <object>(),
                                                  null,
                                                  It.IsAny <Func <object, Exception, string> >()))
            .Callback <Microsoft.Extensions.Logging.LogLevel,
                       EventId,
                       object,
                       Exception,
                       Func <object, Exception, string> >((logLevel, e, state, ex, f) =>
            {
                output.WriteLine($"{logLevel} logged: \"{state}\"");
            });

            _mockSmartThingsAPIHelper = new Mock <ISmartThingsAPIHelper>();
            _mockSmartThingsAPIHelper.Setup(api => api.RefreshTokensAsync(It.IsAny <InstalledAppInstance>()))
            .Returns(() =>
            {
                return(Task.FromResult <InstalledAppInstance>(CommonUtils.GetValidInstalledAppInstance()));
            });

            var iaConfig = new FileBackedConfig <FileBackedInstalledAppManager>()
            {
                BackingStorePath = "data/ia.store"
            };

            var stateConfig = new FileBackedConfig <FileBackedStateManager <string> >()
            {
                BackingStorePath = "data/state.store"
            };

            _mockIAOptions = new Mock <IOptions <FileBackedConfig <FileBackedInstalledAppManager> > >();
            _mockIAOptions.Setup(opt => opt.Value)
            .Returns(iaConfig);

            _mockStateOptions = new Mock <IOptions <FileBackedConfig <FileBackedStateManager <string> > > >();
            _mockStateOptions.Setup(opt => opt.Value)
            .Returns(stateConfig);

            var mockIAFileData = new MockFileData(JsonConvert.SerializeObject(CommonUtils.GetIACache()));

            var mockStateFileData = new MockFileData(JsonConvert.SerializeObject(CommonUtils.GetStateCache()));

            var mockFileSystem = new MockFileSystem();

            mockFileSystem.AddFile("data/ia.store", mockIAFileData);

            mockFileSystem.AddFile("data/state.store", mockStateFileData);

            _mockFileBackedConfigIAValidator = new Mock <FileBackedConfigValidator <FileBackedInstalledAppManager> >();

            _installedAppManager = new FileBackedInstalledAppManager(_mockIALogger.Object,
                                                                     _mockSmartThingsAPIHelper.Object,
                                                                     _mockIAOptions.Object,
                                                                     _mockFileBackedConfigIAValidator.Object,
                                                                     mockFileSystem);

            _mockFileBackedConfigStateValidator = new Mock <FileBackedConfigValidator <FileBackedStateManager <string> > >();

            _stateManager = new FileBackedStateManager <string>(_mockStateLogger.Object,
                                                                _mockStateOptions.Object,
                                                                _mockFileBackedConfigStateValidator.Object,
                                                                mockFileSystem);
        }