public void HaveTwoGenFormEnvironmentsAsSpecifiedInTheTestSourceWithOtherSettings()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("[Secure]iCjhnFwaYyeSWXoL5FL7yw==",
"MIwslAvaU0oJDYCnnjkaA58MCH0XsCxesdeCC1ENpFbgUgbs44XbzxjgOLRrtfou+M7jz2bFIw6PyKXNLXWzikIWkps6lrhYuvIffqCrotM="),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("MyMachine.AcceptanceTest1.Database.SqLite",
"MIwslAvaU0oJDYCnnjkaA58MCH0XsCxesdeCC1ENpFbgUgbs44XbzxjgOLRrtfou+M7jz2bFIw6PyKXNLXWzikIWkps6lrhYuvIffqCrotM="),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("MyMachine.AcceptanceTest1.LogPath.FileSystem", "log path"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("MyMachine.AcceptanceTest1.ExportPath.FileSystem", "export path"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("MyMachine.AcceptanceTest2.Database.SqLite",
"MIwslAvaU0oJDYCnnjkaA58MCH0XsCxesdeCC1ENpFbgUgbs44XbzxjgOLRrtfou+M7jz2bFIw6PyKXNLXWzikIWkps6lrhYuvIffqCrotM="),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("MyMachine.AcceptanceTest2.LogPath.FileSystem", "log path"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("MyMachine.AcceptanceTest2.ExportPath.FileSystem", "export path")
};
_settings = new EnvironmentSettingsCollection(_source);
_environments = new EnvironmentCollection(_settings);
Assert.AreEqual(2, _environments.Count, "There should be two environments");
Assert.AreEqual(3, _environments.Single(e => e.Name == "AcceptanceTest1").Settings.Count(), "Environment AcceptanceTest1 should have 3 settings");
Assert.AreEqual(3, _environments.Single(e => e.Name == "AcceptanceTest2").Settings.Count(), "Environment AcceptanceTest2 should have 3 settings");
var genfCol = new GenFormEnvironmentCollection(_environments);
Assert.AreEqual(2, genfCol.Count, "There should be only two GenForm environments");
}
public static void Register(Action <ContainerBuilder> action)
{
var builder = new Autofac.ContainerBuilder();
builder.Register(x => SettingFactory.Create <PackSetting>()).As <PackSetting>().InstancePerLifetimeScope();
builder.RegisterType <GitCommandHelper>().As <IGitCommandHelper>().InstancePerLifetimeScope();
builder.RegisterType <PathService>().As <IPathService>().SingleInstance();
builder.RegisterType <GitPackEngine>().As <IGitPackEngine>().InstancePerLifetimeScope();
builder.RegisterType <FileAnalysisFactory>().As <IFileAnalysisFactory>().InstancePerLifetimeScope();
builder.RegisterType <ProjectFilePreparer>().As <IChangedFilePreparer>().InstancePerLifetimeScope();
builder.RegisterType <ScreenLogger>().As <ILogger>().SingleInstance();
builder.RegisterType <VisualStudioProjectCompiler>().As <IVisualStudioProjectCompiler>().InstancePerLifetimeScope();
//builder.RegisterType<FakeCompilier>().As<IVisualStudioProjectCompiler>().InstancePerLifetimeScope();
builder.RegisterType <FilePackService>().As <IFilePackService>().InstancePerLifetimeScope();
builder.RegisterType <BuildServiceFactory>().As <IBuildServiceFactory>().InstancePerLifetimeScope();
builder.RegisterType <ProjectParserServiceFactory>().As <IProjectParserServiceFactory>().InstancePerLifetimeScope();
builder.RegisterType <VisualStudioProjectFinder>().As <IProjectFinder>().InstancePerLifetimeScope();
builder.RegisterType <ProjectFilter>().As <IProjectFilter>().SingleInstance();
builder.RegisterType <PackageCompressService>().As <IPackageCompressService>().InstancePerLifetimeScope();
builder.RegisterType <ProjectDiffer>().As <IProjectDiffer>().InstancePerLifetimeScope();
builder.RegisterType <VisualStudioSolutionFinder>().As <ISolutionFinder>().InstancePerLifetimeScope();
builder.RegisterType <VisualStudioSolutionParser>().As <ISolutionParser>().InstancePerLifetimeScope();
builder.RegisterType <NugetPackageManager>().As <INugetPackageManager>().InstancePerLifetimeScope();
action(builder);
IContainer iocContainer = builder.Build();
ContainerManager.SetContainer(iocContainer);
}
public void Load_OfRangeCategoryCountsForVariousFacetsConfigs_ReturnsExpectedValues(string uri)
{
// Arrange
var config = new SettingFactory().Create().Value.Facet;
var mockRegistry = MockRegistryWithFacetRepository();
var mockFacetsConfig = FakeFacetsConfig(uri);
var mockQuerySetupBuilder = MockQuerySetupBuilder(new QuerySetup { /* not used */
});
var mockRangeCountSqlCompiler = MockRangeCategoryCountSqlCompiler(returnSql: "SELECT * FROM foot.bar");
var fakeResult = FakeRangeCategoryCountItems(start: 0, size: 10, count: 3);
var mockQueryProxy = new MockTypedQueryProxyFactory()
.Create <CategoryCountItem>(fakeResult);
// Act
var service = new RangeCategoryCountService(
config,
mockRegistry.Object,
mockQuerySetupBuilder.Object,
mockRangeCountSqlCompiler.Object,
mockQueryProxy.Object
);
var result = service.Load(mockFacetsConfig.TargetFacet.FacetCode, mockFacetsConfig);
// Assert
Assert.NotNull(result);
Assert.NotNull(result.CategoryCounts);
Assert.Equal(fakeResult.Count, result.CategoryCounts.Count);
CompareLogic compareLogic = new CompareLogic();
Assert.True(compareLogic.Compare(fakeResult, result.CategoryCounts.Values.ToList()).AreEqual);
}
//http://stackoverflow.com/questions/5826649/returning-a-file-to-view-download-in-asp-net-mvc
// I have file not found issue
// here is a work around
// https://github.com/aspnet/Mvc/issues/5053
public IActionResult GetKindleFile(string url)
{
// check domain
var firstPageUri = new Uri(url);
if (firstPageUri.Scheme == "file")
{
var note = new MyNote();
var bookHelper = new BookHelper(note);
var kindleFile = bookHelper.CreateKindleFiles(url, true);
}
else
{
// special for thuvienhoasen 1 tac gia
if (firstPageUri.Host == "thuvienhoasen.org" && firstPageUri.Segments.Contains("author/"))
{
var collection = new ThuVienHoaSenCollection();
collection.GetWholeCollection(url);
}
else
{
GeneralSite setting = SettingFactory.Get(url);
if (setting != null)
{
var bookHelper = new BookHelper(setting);
var kindleFile = bookHelper.CreateKindleFiles(url);
}
}
}
return(View("Index"));
}
public void TestCrudSettings()
{
ISetting setting = SettingFactory.CreateSetting();
FillTestSetting(setting);
// DeleteSettingAsync
Task t = db.DeleteSettingAsync(setting.Key);
Assert.IsTrue(!t.IsFaulted);
// InsertSettingAsync
t = db.InsertSettingAsync(setting);
Assert.IsTrue(!t.IsFaulted);
// UpdateSettingAsync
t = db.UpdateSettingAsync(setting.Key, "newvalue");
Assert.IsTrue(!t.IsFaulted);
// GetSettingAsync
t = db.GetSettingAsync(setting.Key);
Assert.IsTrue(!t.IsFaulted);
// DeleteSettingAsync
t = db.DeleteSettingAsync(setting.Key);
Assert.IsTrue(!t.IsFaulted);
}
public static EnvironmentSetting CreateSetting(string machine, string environment, string name, string provider, string value)
{
var setting =
SettingFactory.CreateSecureSetting <ConnectionStringSettings>(
GetSettingKey(machine, environment, name, provider), value);
return(new EnvironmentSetting(setting));
}
public async Task LoadSettingsFromLaunchParam(IReadOnlyDictionary <string, string> launchParams)
{
string param;
if (launchParams.TryGetValue(dirLaunchParam, out param))
{
var di = new DirectoryInfo(param);
DirPath = di.Exists ? di.FullName : Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
}
else
{
ISetting savedir = await SettingFactory.GetSettingDbAsync(pathToDownload).ConfigureAwait(false);
DirPath = savedir.Value;
if (string.IsNullOrEmpty(DirPath))
{
DirPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
}
}
if (launchParams.TryGetValue(mpcLaunchParam, out param))
{
var fn = new FileInfo(param);
if (fn.Exists)
{
MpcPath = fn.FullName;
}
}
else
{
ISetting mpcdir = await SettingFactory.GetSettingDbAsync(pathToMpc).ConfigureAwait(false);
MpcPath = mpcdir.Value;
}
if (launchParams.TryGetValue(youLaunchParam, out param))
{
var fn = new FileInfo(param);
if (fn.Exists)
{
YouPath = fn.FullName;
}
}
else
{
ISetting youpath = await SettingFactory.GetSettingDbAsync(pathToYoudl).ConfigureAwait(false);
YouPath = youpath.Value;
}
ISetting onstartup = await SettingFactory.GetSettingDbAsync(onstartupopen).ConfigureAwait(false);
IsFilterOpen = onstartup.Value != "0";
ISetting isFilterEnabled = await SettingFactory.GetSettingDbAsync(showVideoFiltration).ConfigureAwait(false);
IsVideoFiltrationEnabled = isFilterEnabled.Value != "0";
}
public void CtorTest()
{
Assert.Throws <ArgumentNullException>(() => new SettingFactory <object>(null));
var config = A.Fake <IConfiguration>();
var factory = new SettingFactory <object>(config);
Assert.NotNull(factory);
}
private async Task SaveSettingsToDb()
{
ISetting savedir = await SettingFactory.GetSettingDbAsync(pathToDownload).ConfigureAwait(false);
if (savedir.Value != DirPath)
{
await db.UpdateSettingAsync(savedir.Key, DirPath).ConfigureAwait(false);
onSaveAction?.Invoke(DirPath);
}
ISetting mpcdir = await SettingFactory.GetSettingDbAsync(pathToMpc).ConfigureAwait(false);
if (mpcdir.Value != MpcPath)
{
await db.UpdateSettingAsync(mpcdir.Key, MpcPath).ConfigureAwait(false);
}
ISetting youpath = await SettingFactory.GetSettingDbAsync(pathToYoudl).ConfigureAwait(false);
if (youpath.Value != YouPath)
{
await db.UpdateSettingAsync(youpath.Key, YouPath).ConfigureAwait(false);
}
ISetting onstartup = await SettingFactory.GetSettingDbAsync(onstartupopen).ConfigureAwait(false);
string res = IsFilterOpen ? "1" : "0";
if (onstartup.Value != res)
{
await db.UpdateSettingAsync(onstartup.Key, res).ConfigureAwait(false);
}
ISetting videoFilterEnabled = await SettingFactory.GetSettingDbAsync(showVideoFiltration).ConfigureAwait(false);
string result = IsVideoFiltrationEnabled ? "1" : "0";
if (videoFilterEnabled.Value != result)
{
await db.UpdateSettingAsync(videoFilterEnabled.Key, result).ConfigureAwait(false);
}
foreach (ICred cred in SupportedCreds)
{
await db.UpdateLoginAsync(cred.SiteAdress, cred.Login).ConfigureAwait(false);
await db.UpdatePasswordAsync(cred.SiteAdress, cred.Pass).ConfigureAwait(false);
}
foreach (ITag tag in SupportedTags)
{
await db.InsertTagAsync(tag).ConfigureAwait(false);
}
onSaveAction?.Invoke(null);
}
public void TurnTheSettingNameInMachineEnvironmentNameAndProvider()
{
var source = new TestSource();
var settingname = "TestMachine.TestEnvironment.Test.MyProvider";
source.Add(SettingFactory.CreateSecureSetting(new ConnectionStringSettings(settingname, string.Empty)));
var col = new EnvironmentSettingsCollection(source);
Assert.AreEqual("MyProvider", col.Single(s => s.Name == "Test").Provider);
}
private ISetting WriteAppSetting()
{
var el = new KeyValueConfigurationElement("Test", "Test");
Isolate.WhenCalled(() => el.Key).WillReturn("Test");
var setting = SettingFactory.CreateSecureSetting(el);
_configSettingSource.Add(setting);
return(setting);
}
private async Task PopulateSettings()
{
var settings = _data.Settings();
foreach (var setting in settings)
{
Type settingType = setting.GetType();
int storeId = settingType.Equals(typeof(ThemeSettings)) ? _defaultStoreId : 0;
await SettingFactory.SaveSettingsAsync(_db, setting, storeId);
}
}
public string CreateSettingWithKeyAndValue(string key, string value)
{
try
{
_source.Add(SettingFactory.CreateSecureSetting <ConnectionStringSettings>(key, value));
return(Success);
}
catch (System.Exception e)
{
return(e.ToString());
}
}
public void NotAcceptTwiceASettingWithTheSameNameForTestMachine1AndEnv1()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test1.Provider", "Other test")
};
var col = new EnvironmentSettingsCollection(_source);
Assert.AreEqual(1, col.Count);
}
public static void UpdateSettings(int ModuleID, List <IUIData> Settings)
{
if (Settings != null && Settings.Count > 0)
{
SettingFactory.Update(Settings.Cast <Setting>().ToList());
if (Settings.Where(a => a.Name == "Password").FirstOrDefault() != null)
{
SettingFactory.UpdateValue(ModuleID, AppFactory.Identifiers.admin_notifications_email.ToString(), "Password", FIPSCompliant.EncryptAES(Settings.Where(a => a.Name == "Password").Select(a => new { a.Value }).FirstOrDefault().Value, Config.GetDecryptionkey(), Host.GUID, 1000));
}
CacheFactory.ClearCache();
}
}
public void Constructor_Valid_ShouldCreateSettingFactory()
{
// Prepare
var settingStoreMock = new Mock <ISettingStore>();
var eventAggregatorMock = new Mock <IEventAggregator>();
ISettingFactory settingFactory;
// Act
settingFactory = new SettingFactory(settingStoreMock.Object, eventAggregatorMock.Object);
// Assert
Assert.NotNull(settingFactory);
}
public void UseConfigurationToRemoveAConnectionString()
{
try
{
var setting = SettingFactory.CreateSecureSetting(new ConnectionStringSettings("Test", "Test"));
_configSettingSource.Remove(setting);
Isolate.Verify.WasCalledWithExactArguments(() => _configuration.ConnectionStrings);
}
catch (Exception e)
{
Assert.Fail(e.ToString());
}
}
public void ContainOneEnvironmnentAsSpecifiedInTheTestSource()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test2.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test3.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test4.Provider", "Test")
};
_settings = new EnvironmentSettingsCollection(_source);
var col = new EnvironmentCollection(_settings);
Assert.AreEqual(1, col.Count);
}
public void Create_GetNewAndExistingEvent_ShouldReturnTheSameSettings()
{
// Prepare
var settingStoreMock = new Mock <ISettingStore>();
var eventAggregatorMock = new Mock <IEventAggregator>();
ISettingFactory settingFactory = new SettingFactory(settingStoreMock.Object, eventAggregatorMock.Object);
// Act
var setting1 = settingFactory.Create <ApplicationSettings>();
var setting2 = settingFactory.Create <ApplicationSettings>();
// Assert
Assert.Equal(setting1, setting2);
}
public void ContainFourEnvironmnentsForTestMachine1AsSpecifiedInTheUnsortedTestSource()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env2.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.Env1.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.Env2.Test2.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test2.Provider", "Test")
};
_settings = new EnvironmentSettingsCollection(_source);
var col = new EnvironmentCollection(_settings);
Assert.AreEqual(4, col.Count());
}
private void Init()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>(GetDatabaseSettingName(),
DatabaseConnection),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>(GetLogPathSettingName(),
LogPath),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>(GetExportPathSettingName(),
ExportPath)
};
_settings = new EnvironmentSettingsCollection(_source);
var col = new EnvironmentCollection(_settings);
_environments = new GenFormEnvironmentCollection(col);
}
public static List <IUIData> GetSettings(int ModuleID)
{
CacheFactory.ClearCache();
Dictionary <string, IUIData> Settings = SettingFactory.GetDictionary(ModuleID, AppFactory.Identifiers.admin_notifications_email.ToString());
List <dynamic> ServerTypes = new List <dynamic>
{
new { AuthenticationType = "Anonymous" },
new { AuthenticationType = "NTLM" },
new { AuthenticationType = "Basic" }
};
Settings["Authentication"].Options = ServerTypes;
Settings["Authentication"].OptionsText = "AuthenticationType";
Settings["Authentication"].OptionsValue = "AuthenticationType";
Settings["Password"].Value = FIPSCompliant.DecryptAES(Settings["Password"].Value, Config.GetDecryptionkey(), Host.GUID, 1000);
return(Settings.Values.ToList());
}
public void ContainThreeEnvironmnentSettingsForTestMachine1AndEnv2AsSpecifiedInTheUnsortedTestSource()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env2.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.Env1.Test1.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.Env2.Test2.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env2.Test2.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env2.Test3.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test2.Provider", "Test")
};
_settings = new EnvironmentSettingsCollection(_source);
var col = new EnvironmentCollection(_settings);
Assert.AreEqual(3, col.Single(e => e.MachineName == "TestMachine1" && e.Name == "Env2").Settings.Count());
}
private static void InsertSetting3(SQLiteCommand command, string environment, string version)
{
command.CommandText = ResourceReader.ReadEmbeddedResource <ConfiguationTestSQLite>("Resources.Insert Setting3.sql");
command.Parameters.Clear();
command.Parameters.Add("@Name", DbType.String, 200);
command.Parameters.Add("@Value", DbType.String, -1);
command.Parameters.Add("@Environment", DbType.String, 50);
command.Parameters.Add("@Version", DbType.String, 50);
foreach (var setting in SettingFactory.ReadSettings())
{
command.Parameters["@Name"].Value = setting.Name.ToString();
command.Parameters["@Value"].Value = setting.Value.ToString().Recode(Encoding.UTF8, Encoding.Default);
command.Parameters["@Environment"].Value = environment;
command.Parameters["@Version"].Value = version;
command.ExecuteNonQuery();
}
}
public void HaveOneGenFormEnvironmentWhenOtherEnvironmentTypesWithSameNameInTestSource()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.GenFormEnv.Test1", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env2.Test1", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv.Database.SqLite", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv.LogPath.FileSystem", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test2", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv.ExportPath.FileSystem", "Test")
};
_settings = new EnvironmentSettingsCollection(_source);
_environments = new EnvironmentCollection(_settings);
var genFCol = new GenFormEnvironmentCollection(_environments);
Assert.IsTrue(genFCol.Any());
}
public void UseAEnvironmentsCollectionToGetTheGenFormEnvironments()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Database.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.LogPath.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.ExportPath.Provider", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env2.Test4.Provider", "Test")
};
_settings = new EnvironmentSettingsCollection(_source);
_environments = new EnvironmentCollection(_settings);
var genFCol = new GenFormEnvironmentCollection(_environments);
Isolate.WhenCalled(() => _environments.GetEnumerator()).CallOriginal();
Assert.IsTrue(genFCol.Any());
Isolate.Verify.WasCalledWithAnyArguments(() => _environments.GetEnumerator());
}
public static IContainer Register(Action <ContainerBuilder> action)
{
var builder = new ContainerBuilder();
builder.Register(x => SettingFactory.Create <SystemSetting>()).As <SystemSetting>().SingleInstance();
builder.RegisterGeneric(typeof(MongoRepository <>)).As(typeof(IBaseRepository <>)).InstancePerLifetimeScope();
builder.RegisterType <LogService>().As <ILogService>().InstancePerLifetimeScope();
builder.Register(x => SettingFactory.Create <AliyunMnsSetting>()).As <AliyunMnsSetting>().SingleInstance();
builder.RegisterGeneric(typeof(MqClient <>)).As(typeof(IQueue <>)).InstancePerLifetimeScope();
action(builder);
var container = builder.Build();
Container = container;
return(container);
}
public EnvironmentSettingsCollection GetIsolatedEnvironmentSettingsCollectionWithSettings()
{
SecureSettingSource = new TestSource();
SecureSettingSource.Add(SettingFactory.CreateSecureSetting <ConnectionStringSettings>("MyMachine.TestEnvironment.Database.SqlProvider", "Connection string to database"));
//SettingSource.Add(new Setting("MyMachine.TestEnvironment.Database.SqlProvider", "Connection string to database", "Conn", false));
//SettingSource.Add(new Setting("MyMachine.TestEnvironment.LogPath.FileSystem", "Path to logp", "Conn", false));
//SettingSource.Add(new Setting("MyMachine.TestEnvironment.ExportPath.FileSystem", "Path to export", "Conn", false));
//SettingSource.Add(new Setting("OtherMachine.OtherEnvironment.Database.SqlProvider", "Connection string to database", "Conn", false));
//SettingSource.Add(new Setting("OtherMachine.OtherEnvironment.LogPath.FileSystem", "Path to logp", "Conn", false));
//SettingSource.Add(new Setting("OtherMachine.OtherEnvironment.ExportPath.FileSystem", "Path to export", "Conn", false));
KeyManager = Isolate.Fake.Instance <SecretKeyManager>();
Isolate.WhenCalled(() => KeyManager.GetKey()).WillReturn("secretkey");
CryptoGraphy = new CryptographyAdapter(new SymCryptography());
var col = new EnvironmentSettingsCollection(SecureSettingSource);
return(col);
}
public void HaveTwoGenFormEnvironmentAsSpecifiedInTheTestSource()
{
_source = new TestSource
{
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test1", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env2.Test1", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv1.Database.SqLite", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv1.LogPath.FileSystem", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine1.Env1.Test2", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv1.ExportPath.FileSystem", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv2.Database.SqLite", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv2.LogPath.FileSystem", "Test"),
SettingFactory.CreateSecureSetting <ConnectionStringSettings>("TestMachine2.GenFormEnv2.ExportPath.FileSystem", "Test")
};
_settings = new EnvironmentSettingsCollection(_source);
_environments = new EnvironmentCollection(_settings);
var genFCol = new GenFormEnvironmentCollection(_environments);
Assert.IsTrue(genFCol.Count == 2);
}
public void CreateTest()
{
_objectsCreated = 0;
var config = A.Fake <IConfiguration>();
A.CallTo(() => config.GetItem <object>())
.Returns(CreateNewObject())
.NumberOfTimes(1)
.Then
.Returns(CreateNewObject());
var factory = new SettingFactory <object>(config);
var obj0 = factory.Create();
var obj1 = factory.Create();
Assert.Equal(2, _objectsCreated);
Assert.Equal("c", obj0);
Assert.Equal("cc", obj1);
Assert.NotSame(obj0, obj1);
}
