public void CheckOnlineService()
{
var settings = new MockSettings();
var service = new OnlineService();
object result = null;
var connection = new OnlineServiceConnection(settings,
() => { throw new ConnectionTimedOut(); });
connection.Connected +=
() => connection.Send(new LoginRequest(LoadApiKeyFromRegistry(), "LogoApp"));
connection.DataReceived += message => result = message;
service.Connect("CurrentUser", connection);
Thread.Sleep(500);
Console.WriteLine("User Name: " + service.UserName);
CheckService(service, "LogoApp", result);
Assert.IsFalse(service.IsDeveloper);
bool hasProjectChanged = false;
service.ProjectChanged += () => hasProjectChanged = true;
service.ChangeProject("Asteroids");
Thread.Sleep(500);
Assert.IsTrue(hasProjectChanged);
CheckService(service, "Asteroids", result);
Assert.IsFalse(service.IsDeveloper);
}
public async Task <IActionResult> Put([FromBody] MockSettings mockSettings)
{
try
{
if (mockSettings == null)
{
mockSettings = new MockSettings();
}
var gen = new ListGenerator();
var steps = gen.GetSeps(mockSettings);
var mockLength = mockSettings.MinValue;
for (int i = 0; i < steps.Length - 1; i++)
{
int[] arr = gen.ListOfIntegers(mockLength);
await dataManager.GenerateMocks(string.Join(',', arr), mockLength);
mockLength += (int)steps[i];
}
if (true)
{
return(Ok());
}
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public void SettingsChangeBeforeClose()
{
MockSettings settings = new MockSettings();
settings.Change();
settings.Dispose();
}
public void VerifyPackageReferenceParserTest()
{
string projectPackageReferenceFile = Path.Combine(TestRootPath, "foo.proj");
string projectAssetsJsonFile = Path.Combine(TestRootPath, "project.assets.json");
PackageRestoreData packageRestoreData = LoadPackageRestoreObject(projectPackageReferenceFile, GetTempFileName(), _packageReferenceRestoreFlagContents.Replace("#RestoreOutputPath#", TestRootPath.Replace(@"\", @"\\")));
CreateProjectAssetsJsonFile(projectAssetsJsonFile, (new List <Tuple <string, string> > {
new Tuple <string, string>("Newtonsoft.Json", "6.0.3")
}));
string packagePath = CreatePackagesFolder(new List <Tuple <string, string> > {
new Tuple <string, string>("Newtonsoft.Json", "6.0.3")
}, @"\");
MockSettings settings = new MockSettings
{
{
"config", new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "globalPackagesFolder", packagePath },
}
}
};
bool result = new NuGetPackageReferenceProjectParser(settings, _log).TryGetPackages(packagePath, packageRestoreData, out IEnumerable <PackageIdentityWithPath> packages);
result.ShouldBeTrue();
IList <PackageIdentityWithPath> packageIdentityWithPaths = packages as IList <PackageIdentityWithPath> ?? packages.ToList();
packageIdentityWithPaths.Count.ShouldBe(1);
packageIdentityWithPaths.First().Id.ShouldBe("Newtonsoft.Json");
packageIdentityWithPaths.First().Version.ToString().ShouldBe("6.0.3");
}
private static TestCase[] CreateTestCases()
{
using var settings = MockSettings.Create();
var metres = settings.Metres;
var kilograms = settings.Kilograms;
var seconds = settings.Seconds;
return(new[]
{
new TestCase("m^2", "m²", UnitAndPower.Create(metres, 2)),
new TestCase("m²", "m²", UnitAndPower.Create(metres, 2)),
new TestCase("m³", "m³", UnitAndPower.Create(metres, 3)),
new TestCase("kg⋅m/s²", "kg⋅m/s²", UnitAndPower.Create(kilograms, 1), UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -2)),
new TestCase("kg⋅m⋅s⁻²", "kg⋅m/s²", UnitAndPower.Create(kilograms, 1), UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -2)),
new TestCase("kg*m/s²", "kg⋅m/s²", UnitAndPower.Create(kilograms, 1), UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -2)),
new TestCase("m/s¹", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)),
new TestCase("m⋅s⁻¹", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)),
new TestCase("m¹⋅s^-1", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)),
new TestCase("m^1⋅s^-1", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)),
new TestCase("m¹⋅s⁻¹", "m/s", UnitAndPower.Create(metres, 1), UnitAndPower.Create(seconds, -1)),
new TestCase("1/s", "s⁻¹", UnitAndPower.Create(seconds, -1)),
new TestCase("s^-1", "s⁻¹", UnitAndPower.Create(seconds, -1)),
////new Data("J/s",UnitAndPower.Create(Joules, 1),UnitAndPower.Create(Seconds, -1)),
});
}
public Request(Type type, bool forceMockCreation, MockSettings settings, IDictionary<Type, object> instances)
{
Type = type;
ForceMockCreation = forceMockCreation;
Settings = settings;
Instances = instances;
}
public void GetPackagesPath_WhenPathOrOverrideSpecified_PathIsCorrect(string packagesPathOverride, string packagesPath, string globalPackagesFolder, string expected)
{
using (var testDirectory = TestDirectory.Create())
{
var project = new MockMSBuildProject(testDirectory,
properties: new Dictionary <string, string>
{
["RestorePackagesPath"] = packagesPath
},
globalProperties: new Dictionary <string, string>
{
["RestorePackagesPath"] = packagesPathOverride,
});
var settings = new MockSettings
{
Sections = new[]
{
new MockSettingSection(ConfigurationConstants.Config, new AddItem(ConfigurationConstants.GlobalPackagesFolder, Path.Combine(testDirectory, globalPackagesFolder)))
}
};
var actual = MSBuildStaticGraphRestore.GetPackagesPath(project, settings);
actual.Should().Be(Path.Combine(testDirectory, expected));
}
}
public void GetRepositoryPath_WhenPathSolutionOrOverrideSpecified_CorrectPathDetected(string repositoryPathOverride, string restoreRepositoryPath, string solutionPath, string repositoryPath, string expected)
{
using (var testDirectory = TestDirectory.Create())
{
var project = new MockMSBuildProject(testDirectory, new Dictionary <string, string>
{
["RestoreRepositoryPath"] = restoreRepositoryPath,
["RestoreRepositoryPathOverride"] = repositoryPathOverride,
["SolutionPath"] = solutionPath == null || solutionPath == "*Undefined*" ? solutionPath : UriUtility.GetAbsolutePath(testDirectory, solutionPath)
});
var settings = new MockSettings
{
Sections = new List <SettingSection>
{
new MockSettingSection(
ConfigurationConstants.Config,
repositoryPath == null
? new SettingItem[0]
: new SettingItem[] { new AddItem(ConfigurationConstants.RepositoryPath, UriUtility.GetAbsolutePath(testDirectory, repositoryPath)) })
}
};
var actual = MSBuildStaticGraphRestore.GetRepositoryPath(project, settings);
expected = UriUtility.GetAbsolutePath(testDirectory, expected);
actual.Should().Be(expected);
}
}
public void GetSources_WhenRestoreSourcesSpecified_CorrectSourcesDetected()
{
var project = new MockMSBuildProject(new Dictionary <string, string>
{
["RestoreSources"] = "https://source1;https://source2"
});
var settings = new MockSettings
{
Sections = new List <SettingSection>
{
new MockSettingSection(ConfigurationConstants.PackageSources,
new ClearItem(),
new AddItem("source3", "https://source3"))
}
};
var actual = MSBuildStaticGraphRestore.GetSources(project, new[] { project }, settings);
actual.ShouldBeEquivalentTo(new[]
{
new PackageSource("https://source1"),
new PackageSource("https://source2"),
});
}
public static void SetUnitToKilograms()
{
using var settings = MockSettings.Create();
using var vm = new PartConversionsVm();
vm.SetUnit(settings.Kilograms);
CollectionAssert.IsEmpty(vm.Conversions);
}
public UnitPartsConverterSource()
{
var settings = MockSettings.Create();
this.Metres = settings.Metres;
this.Kilograms = settings.Kilograms;
this.Seconds = settings.Seconds;
this._datas = new List <Data>
{
new Data("m^2", "m²", UnitAndPower.Create(this.Metres, 2)),
new Data("m²", "m²", UnitAndPower.Create(this.Metres, 2)),
new Data("m³", "m³", UnitAndPower.Create(this.Metres, 3)),
new Data("kg⋅m/s²", "kg⋅m/s²", UnitAndPower.Create(this.Kilograms, 1), UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -2)),
new Data("kg⋅m⋅s⁻²", "kg⋅m/s²", UnitAndPower.Create(this.Kilograms, 1), UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -2)),
new Data("kg*m/s²", "kg⋅m/s²", UnitAndPower.Create(this.Kilograms, 1), UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -2)),
new Data("m/s¹", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)),
new Data("m⋅s⁻¹", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)),
new Data("m¹⋅s^-1", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)),
new Data("m^1⋅s^-1", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)),
new Data("m¹⋅s⁻¹", "m/s", UnitAndPower.Create(this.Metres, 1), UnitAndPower.Create(this.Seconds, -1)),
new Data("1/s", "s⁻¹", UnitAndPower.Create(this.Seconds, -1)),
new Data("s^-1", "s⁻¹", UnitAndPower.Create(this.Seconds, -1))
//new Data("J/s",UnitAndPower.Create(Joules, 1),UnitAndPower.Create(Seconds, -1)),
};
}
public object CreateMock(Type serviceType, MockSettings settings)
{
var mock = (Mock) _reflectionHelper.InvokeGenericMethod (s_createMethod, new[] { serviceType }, _repository, new object[] { settings.Behavior });
mock.DefaultValue = settings.DefaultValue;
mock.CallBase = settings.CallBase;
return mock.Object;
}
public void SaveWatchedFileToSettingsOnDispose()
{
var settings = new MockSettings();
var fileWatcher = new MockFileWatcher();
fileWatcher.SetFile(FilePath);
fileWatcher.Dispose();
Assert.AreEqual(FilePath, settings.GetValue(FileWatcher.SettingsKey, ""));
}
public void LoadWatchedFileFromSettingsOnInitialization()
{
var settings = new MockSettings();
string fullFilePath = Path.GetFullPath(FilePath);
settings.SetValue(FileWatcher.SettingsKey, fullFilePath);
var fileWatcher = new MockFileWatcher();
Assert.AreEqual(fullFilePath, fileWatcher.GetCurrentPath());
}
public MockService(string userName, string projectName)
{
UserName = userName;
ProjectName = projectName;
IsDeveloper = true;
EditorSettings = new MockSettings();
availableContentWithCodeProjects = new Dictionary <string, string>();
}
public MockService(string userName, string projectName)
{
UserName = userName;
ProjectName = projectName;
IsDeveloper = true;
EditorSettings = new MockSettings();
availableContentWithCodeProjects = new Dictionary<string, string>();
}
public void Should_Get_Setting()
{
var expected = "1";
var setting = MockSettings.CreateSaveSetting(db, "PostContributionPledgeFunds", "1");
var actual = db.GetSetting("PostContributionPledgeFunds", "");
actual.ShouldBe(expected);
}
public static void MetresToUnitString(int power, string expected)
{
using var settings = MockSettings.Create();
var parts = new[] { UnitAndPower.Create(settings.Metres, power) };
var actual = parts.AsSymbol();
Assert.AreEqual(expected, actual);
}
public void SetUnitToMetresPerSecond()
{
Assert.Inconclusive();
var settings = MockSettings.Create();
var vm = new PartConversionsVm(settings);
vm.SetUnit(settings.MetresPerSecond);
CollectionAssert.AreEqual(new PartConversionsVm[0], vm.Conversions);
}
public void SaveWatchedFileToSettingsOnDispose()
{
var settings = new MockSettings();
var fileWatcher = new MockFileWatcher();
fileWatcher.SetFile(FilePath);
fileWatcher.Dispose();
Assert.AreEqual(FilePath, settings.GetValue(FileWatcher.SettingsKey, ""));
}
public static void SetUnitToMetresPerSecond()
{
Assert.Inconclusive();
//// ReSharper disable once HeuristicUnreachableCode
using var settings = MockSettings.Create();
using var vm = new PartConversionsVm();
vm.SetUnit(settings.MetresPerSecond);
CollectionAssert.IsEmpty(vm.Conversions);
}
public void Defaults()
{
// Arrange
var settings = new MockSettings();
// Assert
settings.Behavior.Should().Be(MockBehavior.Loose);
settings.Verification.Should().Be(MockVerification.All);
}
public void SetUp()
{
this.settings = MockSettings.Create();
this.length = this.settings.Length;
this.speed = this.settings.Speed;
this.time = this.settings.Time;
this.area = this.settings.Area;
this.volume = this.settings.Volume;
}
public void IdentityConversion()
{
var settings = MockSettings.Create();
var conversion = new PartConversion.IdentityConversion(settings.Metres);
Assert.AreEqual("metres", conversion.ToSi);
Assert.AreEqual("metres", conversion.FromSi);
Assert.AreEqual("1 m = 1 m", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public void LoadWatchedFileFromSettingsOnInitialization()
{
var settings = new MockSettings();
string fullFilePath = Path.GetFullPath(FilePath);
settings.SetValue(FileWatcher.SettingsKey, fullFilePath);
var fileWatcher = new MockFileWatcher();
Assert.AreEqual(fullFilePath, fileWatcher.GetCurrentPath());
}
public void FactorConversion()
{
var settings = MockSettings.Create();
var conversion = new FactorConversion("Inches", "in", 0.0254);
settings.Metres.FactorConversions.Add(conversion);
Assert.AreEqual("0.0254*inches", conversion.ToSi);
Assert.AreEqual("metres/0.0254", conversion.FromSi);
Assert.AreEqual("1 in = 0.0254 m", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public void CustomConversionWithIllegal()
{
var settings = MockSettings.Create();
var conversion = new CustomConversion("Fahrenheit", "°F", "??", null);
settings.Kelvins.CustomConversions.Add(conversion);
Assert.AreEqual("??", conversion.ToSi);
Assert.AreEqual(null, conversion.FromSi);
Assert.AreEqual("Invalid", conversion.SymbolConversion);
Assert.AreEqual(false, conversion.CanRoundtrip);
}
public void NestedFactorConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("milligrams/1000000", conversion.ToSi);
Assert.AreEqual("1000000*kilograms", conversion.FromSi);
Assert.AreEqual("1 mg = 1E-06 kg", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public static void Should_Get_Setting()
{
using (var db = CMSDataContext.Create(DatabaseFixture.Host))
{
var expected = "1";
var setting = MockSettings.CreateSaveSetting(db, "PostContributionPledgeFunds", "1");
var actual = db.GetSetting("PostContributionPledgeFunds", "");
actual.ShouldBe(expected);
}
}
protected void Run(string test)
{
var src = Load(this.rule.Name, test);
ISettings settings = new MockSettings();
Compilation compilation = Compilation.Create("test", syntaxTrees: new[] { src });
var target = RuleRewriterFactory.Create(this.rule, settings, () => compilation.GetSemanticModel(src));
var result = target.Visit(src.GetRoot());
var formattedResult = SyntaxTree.Create((CompilationUnitSyntax)result.Format(FormattingOptions.GetDefaultOptions()).GetFormattedRoot(), src.FilePath);
Compare(formattedResult, this.rule.Name, test);
}
public async Task IdentityConversion()
{
var settings = MockSettings.Create();
var conversion = new PartConversion.IdentityConversion(settings.Metres);
Assert.AreEqual("metres", conversion.ToSi);
Assert.AreEqual("metres", conversion.FromSi);
Assert.AreEqual("1 m = 1 m", conversion.SymbolConversion);
Assert.AreEqual(true, await conversion.CanRoundtripAsync().ConfigureAwait(false));
}
public void ReturnsAppIDValueIfInSettings()
{
// Arrange
const string expected = "123456";
var settings = new MockSettings();
settings.Values[FacebookAuthenticator.AppIdKey] = expected;
// Act/Assert
Assert.Equal(expected, new FacebookAuthenticator().GetAppId(settings));
}
public void ThrowsIfWrongParameter()
{
var settings = MockSettings.Create();
var conversion = new CustomConversion("Fahrenheit", "°F", "(fahrenheit + 459.67)/1.8", "1.8*kelvin - 459.67");
settings.Kelvins.CustomConversions.Add(conversion);
var exception = Assert.Throws <ArgumentException>(() => conversion.FromSi = "metres + 45");
Assert.AreEqual("(2,8): error CS0103: The name 'metres' does not exist in the current context", exception.Message);
}
public static void CreateMilligrams()
{
using var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Grams, settings.Milli);
settings.Grams.PrefixConversions.Add(conversion);
Assert.AreEqual("Milligrams", conversion.Name);
Assert.AreEqual("mg", conversion.Symbol);
Assert.AreEqual(1E-6, conversion.Factor);
}
public static void CreateMilliAmperes()
{
using var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Amperes, settings.Milli);
settings.Amperes.PrefixConversions.Add(conversion);
Assert.AreEqual("Milliamperes", conversion.Name);
Assert.AreEqual("mA", conversion.Symbol);
Assert.AreEqual(0.001, conversion.Factor);
}
public void PrefixMicroConversion()
{
var settings = MockSettings.Create();
var conversion = PrefixConversion.Create(settings.Metres, settings.Micro);
settings.Metres.PrefixConversions.Add(conversion);
Assert.AreEqual("micrometres/1000000", conversion.ToSi);
Assert.AreEqual("1000000*metres", conversion.FromSi);
Assert.AreEqual("1 µm = 1E-06 m", conversion.SymbolConversion);
Assert.AreEqual(true, conversion.CanRoundtrip);
}
public static ITestCommand CreateCommand(IMethodInfo methodInfo, ConstructorInfo constructor, MockSettings settings, MockSettings constructorSettings)
{
var requestProvider = new RequestProvider();
var reflectionHelper = new ReflectionHelper();
var mockRepository = new MoqMockRepository (reflectionHelper);
var constructorChooser = new CompositeConstructorChooser (s_constructorChoosers);
var resolver = new Resolver (mockRepository, constructorChooser, reflectionHelper);
var moqResolver = new MoqResolver (resolver);
return new NukitoFactCommand (methodInfo, constructor, requestProvider, moqResolver, reflectionHelper, mockRepository, settings, constructorSettings);
}
public void GramsPerCubicMetre()
{
var settings = MockSettings.Create();
var gramPart = PartConversion.CreatePart(1, settings.Grams);
var volumePart = PartConversion.CreatePart(-1, settings.CubicMetres);
var conversion = PartConversion.Create(settings.KilogramsPerCubicMetre, gramPart, volumePart);
Assert.AreEqual("g/m³", conversion.Symbol);
Assert.AreEqual("GramsPerCubicMetre", conversion.Name);
Assert.AreEqual(1E-3, conversion.Factor);
}
public void CustomConversion()
{
var settings = MockSettings.Create();
var conversion = new CustomConversion("Fahrenheit", "°F", "(fahrenheit + 459.67)/1.8", "1.8*kelvin - 459.67");
settings.Kelvins.CustomConversions.Add(conversion);
Assert.AreEqual("(fahrenheit + 459.67)/1.8", conversion.ToSi);
Assert.AreEqual("1.8*kelvin - 459.67", conversion.FromSi);
Assert.AreEqual("1 °F = 255.927777777778 K", conversion.SymbolConversion);
Assert.Inconclusive("Does not roundtrip cleanly");
//Assert.AreEqual(true, conversion.CanRoundtrip);
}
public void TestExceptions()
{
var settings = new MockSettings { UpdatesPerSecond = 0 };
Assert.Throws<EntitiesRunner.InvalidUpdatePerSecondSettings>(
() => new EntitiesRunner(new MockBehaviorResolver(), settings));
Assert.Throws<EntitiesRunner.InvalidUpdatePerSecondSettings>(
() => EntitiesRunner.Current.ChangeUpdateTimeStep(0));
Assert.Throws<EntitiesRunner.YouAreNotAllowedToDrawOutsideOfTheDrawLoop>(
() => EntitiesRunner.Current.CheckIfInDrawState());
Assert.Throws<EntitiesRunner.UnableToResolveBehavior>(
() => EntitiesRunner.Current.GetDrawBehavior<DrawBehavior>());
}
public void Merge()
{
// Arrange
var classSettings = new MockSettings {Behavior = MockBehavior.Strict, Verification = MockVerification.None};
var methodSettings = new MockSettings {Behavior = MockBehavior.Loose};
// Act
var merged = MockSettings.Merge(classSettings, methodSettings);
// Assert
merged.Behavior.Should().Be(MockBehavior.Loose);
merged.Verification.Should().Be(MockVerification.None);
}
private static Settings GetMockSettingsWithAlreadyBuiltApps()
{
var settings = new MockSettings();
var storageData = new XmlData("BuiltApps");
storageData.AddAttribute("StoragePath", storageData.Name);
settings.SetValue(storageData.Name, storageData);
var appsStorage = new AppsStorage(settings);
appsStorage.AddApp(new WindowsAppInfo("Rebuildable app", Guid.NewGuid(), DateTime.Now)
{
SolutionFilePath = "A.sln"
});
appsStorage.AddApp(new WindowsAppInfo("Non-Rebuildable app ", Guid.NewGuid(), DateTime.Now));
return settings;
}
public NukitoFactCommandTest(Mock<IMethodInfo> method, Mock<IRequestProvider> requestProvider, Mock<IResolver> resolver, Mock<IReflectionHelper> reflectionHelper, Mock<IMockRepository> repository)
{
_method = method;
_requestProvider = requestProvider;
_fakeConstructor = typeof (string).GetConstructor (new[] { typeof (char[]) });
_ctorArgType = _fakeConstructor.GetParameters().Single().ParameterType;
_resolver = resolver;
_reflectionHelper = reflectionHelper;
_repository = repository;
_settings = new MockSettings();
_ctorSettings = new MockSettings();
_command = new NukitoFactCommand (method.Object, _fakeConstructor, requestProvider.Object, resolver.Object, reflectionHelper.Object, repository.Object, _settings, _ctorSettings);
}
public void AbsoluteSolutionFilePathDependsOnTheSelectedContentProject()
{
var settings = new MockSettings();
var service = new OnlineService();
var connection = new OnlineServiceConnection(settings,
() => { throw new ConnectionTimedOut(); });
service.Connect("CurrentUser", connection);
Assert.AreEqual("", service.CurrentContentProjectSolutionFilePath);
service.ChangeProject("LogoApp");
Thread.Sleep(1000);
AssertSolutionFilePath(GetSamplesSlnPath(), service);
service.ChangeProject("DeltaEngine.Tutorials");
Thread.Sleep(1000);
AssertSolutionFilePath(GetTutorialsSlnPath(), service);
}
public void GetRetrievesConfigFromInnerValue(MoqResolver moqResolver, Mock<IResolver> innerResolver, MockSettings settings)
{
// Arrange
var instances = new Dictionary<Type, object>();
var fakeInnerValue = new Mock<IMocked>();
innerResolver
.Setup (x => x.Get (It.Is ((Request r) => r.Type == typeof (string) && r.ForceMockCreation && r.Settings == settings && r.Instances == instances)))
.Returns (fakeInnerValue.Object);
// Act
var result = moqResolver.Get (new Request (typeof (Mock<string>), false, settings, instances));
// Assert
result.Should ().BeSameAs (fakeInnerValue);
}
public void InitializesValues()
{
// Arrange
var data = new MockDataRepository();
var tokens = new TokenService();
var settings = new MockSettings();
// Act
AuthenticationService auth = new AuthenticationService(data, tokens, settings);
// Assert
Assert.Same(data, auth.Data);
Assert.Same(tokens, auth.Tokens);
Assert.Same(settings, auth.Settings);
Assert.Equal(TimeSpan.FromMinutes(30), auth.Timeout);
}
public NukitoFactCommand(
IMethodInfo method,
ConstructorInfo constructor,
IRequestProvider requestProvider,
IResolver resolver,
IReflectionHelper reflectionHelper,
IMockRepository mockRepository,
MockSettings settings,
MockSettings constructorSettings)
: base(method)
{
_constructor = constructor;
_requestProvider = requestProvider;
_resolver = resolver;
_reflectionHelper = reflectionHelper;
_mockRepository = mockRepository;
_settings = settings;
_constructorSettings = constructorSettings;
}
public void CreateMock()
{
// Arrange
var settings = new MockSettings
{
Behavior = MockBehavior.Loose,
DefaultValue = DefaultValue.Empty,
CallBase = true
};
// Act
var result = _repository.CreateMock (typeof (IA), settings);
// Assert
result.Should().BeAssignableTo<IA>();
result.Should().BeAssignableTo<IMocked<IA>> ();
var configuration = ((IMocked<IA>) result).Mock;
configuration.Behavior.Should ().Be (settings.Behavior);
configuration.DefaultValue.Should ().Be (settings.DefaultValue);
configuration.CallBase.Should ().Be (settings.CallBase);
}
public void CheckOnlineService()
{
var settings = new MockSettings();
var service = new OnlineService();
object result = null;
var connection = new OnlineServiceConnection(settings,
() => { throw new ConnectionTimedOut(); });
connection.Connected +=
() => connection.Send(new LoginRequest(LoadApiKeyFromRegistry(), "LogoApp"));
connection.DataReceived += message => result = message;
service.Connect("CurrentUser", connection);
Thread.Sleep(500);
Console.WriteLine("User Name: " + service.UserName);
CheckService(service, "LogoApp", result);
Assert.IsFalse(service.IsDeveloper);
bool hasProjectChanged = false;
service.ProjectChanged += () => hasProjectChanged = true;
service.ChangeProject("Asteroids");
Thread.Sleep(500);
Assert.IsTrue(hasProjectChanged);
CheckService(service, "Asteroids", result);
Assert.IsFalse(service.IsDeveloper);
}
public void CreateAppsListViewModel()
{
editorSettings = new MockSettings();
appListViewModel = new BuiltAppsListViewModel(editorSettings);
}
public void SetRenderSize()
{
var loadedMaterial = ContentLoader.Load<Material>("DefaultMaterial");
var resolution = new MockSettings().Resolution;
loadedMaterial.RenderSizeMode = RenderSizeMode.PixelBased;
var pixelBasedSize = ScreenSpace.Current.ToPixelSpace(loadedMaterial.MaterialRenderSize);
Assert.AreEqual(new Size(128), pixelBasedSize);
SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor800X480, 800);
SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor1024X768, 1024);
SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor1280X720, 1280);
SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeFor1920X1080, 1920);
SetPixelModeAndCheckTargetResolution(loadedMaterial, RenderSizeMode.SizeForSettingsResolution, resolution.Width);
}
private object[] CreateArguments(MethodBase methodBase, MockSettings settings)
{
return methodBase.GetParameters()
.Select (p => _resolver.Get (_requestProvider.GetRequest (GetContextName (p), p.ParameterType, settings)))
.ToArray();
}
public Request GetRequest(string contextName, Type parameterType, MockSettings settings)
{
var instances = GetOrCreateContext (contextName);
return new Request (parameterType, false, settings, instances);
}
public void SettingsChangeBeforeClose()
{
MockSettings settings = new MockSettings();
settings.Change();
settings.Dispose();
}
public void InitializesValues()
{
// Arrange
var data = new MockDataRepository();
var auths = new List<Authenticator>() { new FacebookAuthenticator() };
var settings = new MockSettings();
// Act
AuthenticationService auth = new AuthenticationService(auths, settings, data);
// Assert
Assert.Same(data, auth.Data);
Assert.Equal(1, auth.Authenticators.Count);
Assert.Same(auths[0], auth.Authenticators["fb"]);
Assert.Same(settings, auth.Settings);
}
public TestableAuthenticationService()
{
Data = MockData = new MockDataRepository();
Tokens = MockTokens = new MockTokenService();
Settings = MockSettings = new MockSettings();
TokenExchanges = new Dictionary<string, HttpResponseMessage>();
}
public MockSettingsAttribute()
{
Settings = new MockSettings();
}
private Action GetTest(Action<Mock<IB>> method, MockSettings settings = null)
{
return TestUtility.GetTest(method, settings: settings);
}
public void CreateEmptySettings()
{
settings = new MockSettings();
}
public TestableAuthenticationService()
{
Authenticators = new Dictionary<string, Authenticator>() {
{"fb", new FacebookAuthenticator()}
};
Data = MockData = new MockDataRepository();
Settings = MockSettings = new MockSettings();
TokenExchanges = new Dictionary<string, UserInfo>();
}
